<?php

class nusoap_base {
var $title = 'NuSOAP';
var $version = '0.6.6';
var $error_str = false;
var $debug_str = '';
var $charencoding = true;
var $XMLSchemaVersion = 'http://www.w3.org/2001/XMLSchema';
var $soap_defencoding = 'UTF-8';
var $namespaces = array(
'SOAP'=>'http://schemas.xmlsoap.org/soap/envelope/',
'xsd'=>'http://www.w3.org/2001/XMLSchema',
'xsi'=>'http://www.w3.org/2001/XMLSchema-instance'
);
var $typemap = array(
'http://www.w3.org/2001/XMLSchema'=>array(
'string'=>'string','boolean'=>'boolean','float'=>'double','double'=>'double','decimal'=>'double',
'duration'=>'','dateTime'=>'string','time'=>'string','date'=>'string','gYearMonth'=>'',
'gYear'=>'','gMonthDay'=>'','gDay'=>'','gMonth'=>'','hexBinary'=>'string','base64Binary'=>'string',
'normalizedString'=>'string','token'=>'string','language'=>'','NMTOKEN'=>'','NMTOKENS'=>'','Name'=>'','NCName'=>'','ID'=>'',
'IDREF'=>'','IDREFS'=>'','ENTITY'=>'','ENTITIES'=>'','integer'=>'integer','nonPositiveInteger'=>'integer',
'negativeInteger'=>'integer','long'=>'integer','int'=>'integer','short'=>'integer','byte'=>'integer','nonNegativeInteger'=>'integer',
'unsignedLong'=>'','unsignedInt'=>'','unsignedShort'=>'','unsignedByte'=>'','positiveInteger'=>''),
'http://www.w3.org/1999/XMLSchema'=>array(
'i4'=>'','int'=>'integer','boolean'=>'boolean','string'=>'string','double'=>'double',
'float'=>'double','dateTime'=>'string',
'timeInstant'=>'string','base64Binary'=>'string','base64'=>'string','ur-type'=>'array'),
'http://soapinterop.org/xsd'=>array('SOAPStruct'=>'struct'),
'http://schemas.xmlsoap.org/soap/encoding/'=>array('base64'=>'string','array'=>'array','Array'=>'array'),
'http://xml.apache.org/xml-soap'=>array('Map')
);
var $xmlEntities = array('quot'=>'"','amp'=>'&',
'lt'=>'<','gt'=>'>','apos'=>"'");
function debug($string){
$this->debug_str .= get_class($this).": $string\n";
}
function expandEntities($val) {
if ($this->charencoding) {
$val = str_replace('&','&amp;',$val);
$val = str_replace("'",'&apos;',$val);
$val = str_replace('"','&quot;',$val);
$val = str_replace('<','&lt;',$val);
$val = str_replace('>','&gt;',$val);
}
return $val;
}
function getError(){
if($this->error_str != ''){
return $this->error_str;
}
return false;
}
function setError($str){
$this->error_str = $str;
}
function serialize_val($val,$name=false,$type=false,$name_ns=false,$type_ns=false,$attributes=false,$use='encoded'){
if(is_object($val) &&get_class($val) == 'soapval'){
return $val->serialize($use);
}
$this->debug( "in serialize_val: $val, $name, $type, $name_ns, $type_ns, $attributes, $use");
$name = (!$name||is_numeric($name)) ?'soapVal': $name;
$xmlns = '';
if($name_ns){
$prefix = 'nu'.rand(1000,9999);
$name = $prefix.':'.$name;
$xmlns .= " xmlns:$prefix=\"$name_ns\"";
}
if($type_ns != ''&&$type_ns == $this->namespaces['xsd']){
$type_prefix = 'xsd';
}elseif($type_ns){
$type_prefix = 'ns'.rand(1000,9999);
$xmlns .= " xmlns:$type_prefix=\"$type_ns\"";
}
$atts = '';
if($attributes){
foreach($attributes as $k =>$v){
$atts .= " $k=\"$v\"";
}
}
if($type != ''&&isset($this->typemap[$this->XMLSchemaVersion][$type])){
if(is_bool($val) &&!$val){
$val = 0;
}else if (is_string($val)) {
$val = $this->expandEntities($val);
}
if ($use == 'literal') {
return "<$name$xmlns>$val</$name>";
}else {
return "<$name$xmlns xsi:type=\"xsd:$type\">$val</$name>";
}
}
$xml = '';
switch(true) {
case ($type == ''&&is_null($val)):
if ($use == 'literal') {
$xml .= "<$name$xmlns/>";
}else {
$xml .= "<$name$xmlns xsi:nil=\"true\"/>";
}
break;
case (is_bool($val) ||$type == 'boolean'):
if(!$val){
$val = 0;
}
if ($use == 'literal') {
$xml .= "<$name$xmlns $atts>$val</$name>";
}else {
$xml .= "<$name$xmlns xsi:type=\"xsd:boolean\"$atts>$val</$name>";
}
break;
case (is_int($val) ||is_long($val) ||$type == 'int'):
if ($use == 'literal') {
$xml .= "<$name$xmlns $atts>$val</$name>";
}else {
$xml .= "<$name$xmlns xsi:type=\"xsd:int\"$atts>$val</$name>";
}
break;
case (is_float($val)||is_double($val) ||$type == 'float'):
if ($use == 'literal') {
$xml .= "<$name$xmlns $atts>$val</$name>";
}else {
$xml .= "<$name$xmlns xsi:type=\"xsd:float\"$atts>$val</$name>";
}
break;
case (is_string($val) ||$type == 'string'):
$val = $this->expandEntities($val);
if ($use == 'literal') {
$xml .= "<$name$xmlns $atts>$val</$name>";
}else {
$xml .= "<$name$xmlns xsi:type=\"xsd:string\"$atts>$val</$name>";
}
break;
case is_object($val):
$name = get_class($val);
foreach(get_object_vars($val) as $k =>$v){
$pXml = isset($pXml) ?$pXml.$this->serialize_val($v,$k,false,false,false,false,$use) : $this->serialize_val($v,$k,false,false,false,false,$use);
}
$xml .= '<'.$name.'>'.$pXml.'</'.$name.'>';
break;
break;
case (is_array($val) ||$type):
$keyList = array_keys($val);
$valueType = 'arraySimple';
foreach($keyList as $keyListValue){
if(!is_int($keyListValue)){
$valueType = 'arrayStruct';
break;
}
}
if($valueType=='arraySimple'||ereg('^ArrayOf',$type)){
$i = 0;
if(is_array($val) &&count($val)>0){
foreach($val as $v){
if(is_object($v) &&get_class($v) ==  'soapval'){
$tt_ns = $v->type_ns;
$tt = $v->type;
}else {
$tt = gettype($v);
}
$array_types[$tt] = 1;
$xml .= $this->serialize_val($v,'item',false,false,false,false,$use);
++$i;
}
if(count($array_types) >1){
$array_typename = 'xsd:ur-type';
}elseif(isset($tt) &&isset($this->typemap[$this->XMLSchemaVersion][$tt])) {
$array_typename = 'xsd:'.$tt;
}elseif($tt == 'array'||$tt == 'Array'){
$array_typename = 'SOAP-ENC:Array';
}else {
if ($tt_ns != ''&&$tt_ns == $this->namespaces['xsd']){
$array_typename = 'xsd:'.$tt;
}elseif ($tt_ns) {
$tt_prefix = 'ns'.rand(1000,9999);
$array_typename = "$tt_prefix:$tt";
$xmlns .= " xmlns:$tt_prefix=\"$tt_ns\"";
}else {
$array_typename = $tt;
}
}
$array_type = $i;
if ($use == 'literal') {
$type_str = '';
}else if (isset($type) &&isset($type_prefix)) {
$type_str = " xsi:type=\"$type_prefix:$type\"";
}else {
$type_str = " xsi:type=\"SOAP-ENC:Array\" SOAP-ENC:arrayType=\"".$array_typename."[$array_type]\"";
}
}else {
if ($use == 'literal') {
$type_str = '';
}else if (isset($type) &&isset($type_prefix)) {
$type_str = " xsi:type=\"$type_prefix:$type\"";
}else {
$type_str = " xsi:type=\"SOAP-ENC:Array\"";
}
}
$xml = "<$name$xmlns$type_str$atts>".$xml."</$name>";
}else {
if(isset($type) &&isset($type_prefix)){
$type_str = " xsi:type=\"$type_prefix:$type\"";
}else {
$type_str = '';
}
if ($use == 'literal') {
$xml .= "<$name$xmlns $atts>";
}else {
$xml .= "<$name$xmlns$type_str$atts>";
}
foreach($val as $k =>$v){
if ($type == 'Map'&&$type_ns == 'http://xml.apache.org/xml-soap') {
$xml .= '<item>';
$xml .= $this->serialize_val($k,'key',false,false,false,false,$use);
$xml .= $this->serialize_val($v,'value',false,false,false,false,$use);
$xml .= '</item>';
}else {
$xml .= $this->serialize_val($v,$k,false,false,false,false,$use);
}
}
$xml .= "</$name>";
}
break;
default:
$xml .= 'not detected, got '.gettype($val).' for '.$val;
break;
}
return $xml;
}
function serializeEnvelope($body,$headers=false,$namespaces=array(),$style=''){
$ns_string = '';
foreach(array_merge($this->namespaces,$namespaces) as $k =>$v){
$ns_string .= "  xmlns:$k=\"$v\"";
}
if($style == 'rpc') {
$ns_string = ' SOAP:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"'.$ns_string;
}
if($headers){
$headers = "<SOAP:Header>".$headers."</SOAP:Header>";
}
return
'<?xml version="1.0" encoding="'.$this->soap_defencoding .'"?'.">".
'<SOAP:Envelope'.$ns_string.">".
$headers.
"<SOAP:Body>".
$body.
"</SOAP:Body>".
"</SOAP:Envelope>";
}
function formatDump($str){
$str = htmlspecialchars($str);
return nl2br($str);
}
function getLocalPart($str){
if($sstr = strrchr($str,':')){
return substr( $sstr,1 );
}else {
return $str;
}
}
function getPrefix($str){
if($pos = strrpos($str,':')){
return substr($str,0,$pos);
}
return false;
}
function varDump($data) {
ob_start();
var_dump($data);
$ret_val = ob_get_contents();
ob_end_clean();
return $ret_val;
}
}
function timestamp_to_iso8601($timestamp,$utc=true){
$datestr = date('Y-m-d\TH:i:sO',$timestamp);
if($utc){
$eregStr =
'([0-9]{4})-'.
'([0-9]{2})-'.
'([0-9]{2})'.
'T'.
'([0-9]{2}):'.
'([0-9]{2}):'.
'([0-9]{2})(\.[0-9]*)?'.
'(Z|[+\-][0-9]{2}:?[0-9]{2})?';
if(ereg($eregStr,$datestr,$regs)){
return sprintf('%04d-%02d-%02dT%02d:%02d:%02dZ',$regs[1],$regs[2],$regs[3],$regs[4],$regs[5],$regs[6]);
}
return false;
}else {
return $datestr;
}
}
function iso8601_to_timestamp($datestr){
$eregStr =
'([0-9]{4})-'.
'([0-9]{2})-'.
'([0-9]{2})'.
'T'.
'([0-9]{2}):'.
'([0-9]{2}):'.
'([0-9]{2})(\.[0-9]+)?'.
'(Z|[+\-][0-9]{2}:?[0-9]{2})?';
if(ereg($eregStr,$datestr,$regs)){
if($regs[8] != 'Z'){
$op = substr($regs[8],0,1);
$h = substr($regs[8],1,2);
$m = substr($regs[8],strlen($regs[8])-2,2);
if($op == '-'){
$regs[4] = $regs[4] +$h;
$regs[5] = $regs[5] +$m;
}elseif($op == '+'){
$regs[4] = $regs[4] -$h;
$regs[5] = $regs[5] -$m;
}
}
return strtotime("$regs[1]-$regs[2]-$regs[3] $regs[4]:$regs[5]:$regs[6]Z");
}else {
return false;
}
}
function usleepWindows($usec)
{
$start = gettimeofday();
do
{
$stop = gettimeofday();
$timePassed = 1000000 * ($stop['sec'] -$start['sec'])
+$stop['usec'] -$start['usec'];
}
while ($timePassed <$usec);
}
class soap_fault extends nusoap_base {
var $faultcode;
var $faultactor;
var $faultstring;
var $faultdetail;
function soap_fault($faultcode,$faultactor='',$faultstring='',$faultdetail=''){
$this->faultcode = $faultcode;
$this->faultactor = $faultactor;
$this->faultstring = $faultstring;
$this->faultdetail = $faultdetail;
}
function serialize(){
$ns_string = '';
foreach($this->namespaces as $k =>$v){
$ns_string .= "\n  xmlns:$k=\"$v\"";
}
$return_msg =
'<?xml version="1.0" encoding="'.$this->soap_defencoding.'"?>'.
'<SOAP:Envelope SOAP:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"'.$ns_string.">\n".
'<SOAP:Body>'.
'<SOAP:Fault>'.
'<faultcode>'.$this->expandEntities($this->faultcode).'</faultcode>'.
'<faultactor>'.$this->expandEntities($this->faultactor).'</faultactor>'.
'<faultstring>'.$this->expandEntities($this->faultstring).'</faultstring>'.
'<detail>'.$this->serialize_val($this->faultdetail).'</detail>'.
'</SOAP:Fault>'.
'</SOAP:Body>'.
'</SOAP:Envelope>';
return $return_msg;
}
}
class XMLSchema extends nusoap_base  {
var $schema = '';
var $xml = '';
var $complexTypes = array();
var $schemaTargetNamespace = '';
var $parser;
var $position;
var $depth = 0;
var $depth_array = array();
function XMLSchema($schema='',$xml=''){
$this->debug('xmlschema class instantiated, inside constructor');
$this->schema = $schema;
$this->xml = $xml;
if($schema != ''){
$this->debug('initial schema file: '.$schema);
$this->parseFile($schema);
}
if($xml != ''){
$this->debug('initial xml file: '.$xml);
$this->parseFile($xml);
}
}
function parseFile($xml,$type){
if($xml != ""){
$this->debug('parsing $xml');
$xmlStr = @join("",@file($xml));
if($xmlStr == ""){
$this->setError('No file at the specified URL: '.$xml);
return false;
}else {
$this->parseString($xmlStr,$type);
return true;
}
}
return false;
}
function parseString($xml,$type){
if($xml != ""){
$this->parser = xml_parser_create();
xml_parser_set_option($this->parser,XML_OPTION_CASE_FOLDING,0);
xml_set_object($this->parser,$this);
if($type == "schema"){
xml_set_element_handler($this->parser,'schemaStartElement','schemaEndElement');
xml_set_character_data_handler($this->parser,'schemaCharacterData');
}elseif($type == "xml"){
xml_set_element_handler($this->parser,'xmlStartElement','xmlEndElement');
xml_set_character_data_handler($this->parser,'xmlCharacterData');
}
if(!xml_parse($this->parser,$xml,true)){
$errstr = sprintf('XML error on line %d: %s',
xml_get_current_line_number($this->parser),
xml_error_string(xml_get_error_code($this->parser))
);
$this->debug('XML parse error: '.$errstr);
$this->setError('Parser error: '.$errstr);
}
xml_parser_free($this->parser);
}else{
$this->debug('no xml passed to parseString()!!');
$this->setError('no xml passed to parseString()!!');
}
}
function schemaStartElement($parser,$name,$attrs) {
$pos = $this->position++;
$depth = $this->depth++;
$this->depth_array[$depth] = $pos;
if($prefix = $this->getPrefix($name)){
$name = $this->getLocalPart($name);
}else {
$prefix = '';
}
if(count($attrs) >0){
foreach($attrs as $k =>$v){
if(ereg("^xmlns",$k)){
if($ns_prefix = substr(strrchr($k,':'),1)){
$this->namespaces[$ns_prefix] = $v;
}else {
$this->namespaces['ns'.(count($this->namespaces)+1)] = $v;
}
if($v == 'http://www.w3.org/2001/XMLSchema'||$v == 'http://www.w3.org/1999/XMLSchema'){
$this->XMLSchemaVersion = $v;
$this->namespaces['xsi'] = $v.'-instance';
}
}
}
foreach($attrs as $k =>$v){
$k = strpos($k,':') ?$this->expandQname($k) : $k;
$v = strpos($v,':') ?$this->expandQname($v) : $v;
$eAttrs[$k] = $v;
}
$attrs = $eAttrs;
}else {
$attrs = array();
}
switch($name){
case ('all'|'choice'|'sequence'):
$this->complexTypes[$this->currentComplexType]['compositor'] = $name;
if($name == 'all'){
$this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
}
break;
case 'attribute':
if(isset($attrs['name'])){
$this->attributes[$attrs['name']] = $attrs;
$aname = $attrs['name'];
}elseif(isset($attrs['ref']) &&$attrs['ref'] == 'http://schemas.xmlsoap.org/soap/encoding/:arrayType'){
$aname = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
}elseif(isset($attrs['ref'])){
$aname = $attrs['ref'];
$this->attributes[$attrs['ref']] = $attrs;
}
if(isset($this->currentComplexType)){
$this->complexTypes[$this->currentComplexType]['attrs'][$aname] = $attrs;
}elseif(isset($this->currentElement)){
$this->elements[$this->currentElement]['attrs'][$aname] = $attrs;
}
if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']) ||$this->getLocalPart($aname) == 'arrayType'){
$this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
$prefix = $this->getPrefix($aname);
if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])){
$v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
}else {
$v = '';
}
if(strpos($v,'[,]')){
$this->complexTypes[$this->currentComplexType]['multidimensional'] = true;
}
$v = substr($v,0,strpos($v,'['));
if(!strpos($v,':') &&isset($this->typemap[$this->XMLSchemaVersion][$v])){
$v = $this->XMLSchemaVersion.':'.$v;
}
$this->complexTypes[$this->currentComplexType]['arrayType'] = $v;
}
break;
case 'complexType':
if(isset($attrs['name'])){
$this->currentElement = false;
$this->currentComplexType = $attrs['name'];
$this->complexTypes[$this->currentComplexType] = $attrs;
$this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';
if(isset($attrs['base']) &&ereg(':Array$',$attrs['base'])){
$this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
}else {
$this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
}
$this->xdebug('processing complexType '.$attrs['name']);
}
break;
case 'element':
if(isset($attrs['type'])){
$this->xdebug("processing element ".$attrs['name']);
$this->currentElement = $attrs['name'];
$this->elements[$attrs['name'] ] = $attrs;
$this->elements[$attrs['name'] ]['typeClass'] = 'element';
$ename = $attrs['name'];
}elseif(isset($attrs['ref'])){
$ename = $attrs['ref'];
}else {
$this->xdebug('adding complexType '.$attrs['name']);
$this->currentComplexType = $attrs['name'];
$this->complexTypes[$attrs['name'] ] = $attrs;
$this->complexTypes[$attrs['name'] ]['element'] = 1;
$this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
}
if(isset($ename) &&$this->currentComplexType){
$this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs;
}
break;
case 'restriction':
$this->xdebug("in restriction for ct: $this->currentComplexType and ce: $this->currentElement");
if($this->currentElement){
$this->elements[$this->currentElement]['type'] = $attrs['base'];
}elseif($this->currentComplexType){
$this->complexTypes[$this->currentComplexType]['restrictionBase'] = $attrs['base'];
if(strstr($attrs['base'],':') == ':Array'){
$this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
}
}
break;
case 'schema':
$this->schema = $attrs;
$this->schema['schemaVersion'] = $this->getNamespaceFromPrefix($prefix);
break;
case 'simpleType':
if(isset($attrs['name'])){
$this->currentElement = $attrs['name'];
$this->elements[$attrs['name'] ] = $attrs;
$this->elements[$attrs['name'] ]['typeClass'] = 'element';
}else {
}
break;
}
}
function schemaEndElement($parser,$name) {
if(isset($this->depth_array[$this->depth])){
$pos = $this->depth_array[$this->depth];
}
$this->depth--;
if($name == 'complexType'){
$this->currentComplexType = false;
$this->currentElement = false;
}
if($name == 'element'){
$this->currentElement = false;
}
}
function schemaCharacterData($parser,$data){
$pos = $this->depth_array[$this->depth];
$this->message[$pos]['cdata'] .= $data;
}
function serializeSchema(){
$schemaPrefix = $this->getPrefixFromNamespace($this->XMLSchemaVersion);
$xml = '';
foreach($this->complexTypes as $typeName =>$attrs){
$contentStr = '';
if(count($attrs['elements']) >0){
foreach($attrs['elements'] as $element =>$eParts){
if(isset($eParts['ref'])){
$contentStr .= "<$schemaPrefix:element ref=\"$element\"/>";
}else {
$contentStr .= "<$schemaPrefix:element name=\"$element\" type=\"$eParts[type]\"/>";
}
}
}
if(count($attrs['attrs']) >= 1){
foreach($attrs['attrs'] as $attr =>$aParts){
$contentStr .= "<$schemaPrefix:attribute ref=\"".$aParts['ref'].'"';
if(isset($aParts['wsdl:arrayType'])){
$contentStr .= ' wsdl:arrayType="'.$aParts['wsdl:arrayType'].'"';
}
$contentStr .= '/>';
}
}
if( isset($attrs['restrictionBase']) &&$attrs['restrictionBase'] != ''){
$contentStr = "<$schemaPrefix:restriction base=\"".$attrs['restrictionBase']."\">".$contentStr."</$schemaPrefix:restriction>";
}
if(isset($attrs['compositor']) &&$attrs['compositor'] == 'all'){
$contentStr = "<$schemaPrefix:$attrs[compositor]>".$contentStr."</$schemaPrefix:$attrs[compositor]>";
}
elseif( count($attrs['elements']) >0 ||count($attrs['attrs']) >0){
$contentStr = "<$schemaPrefix:complexContent>".$contentStr."</$schemaPrefix:complexContent>";
}
if(isset($attrs['compositor']) &&$attrs['compositor'] != ''&&$attrs['compositor'] != 'all'){
$contentStr = "<$schemaPrefix:$attrs[compositor]>".$contentStr."</$schemaPrefix:$attrs[compositor]>";
}
if($contentStr != ''){
$contentStr = "<$schemaPrefix:complexType name=\"$typeName\">".$contentStr."</$schemaPrefix:complexType>";
}else {
$contentStr = "<$schemaPrefix:complexType name=\"$typeName\"/>";
}
$xml .= $contentStr;
}
if(isset($this->elements) &&count($this->elements) >0){
foreach($this->elements as $element =>$eParts){
$xml .= "<$schemaPrefix:element name=\"$element\" type=\"".$eParts['type']."\"/>";
}
}
if(isset($this->attributes) &&count($this->attributes) >0){
foreach($this->attributes as $attr =>$aParts){
$xml .= "<$schemaPrefix:attribute name=\"$attr\" type=\"".$aParts['type']."\"/>";
}
}
$xml = "<$schemaPrefix:schema targetNamespace=\"$this->schemaTargetNamespace\"><$schemaPrefix:import namespace=\"http://schemas.xmlsoap.org/soap/encoding/\" /><$schemaPrefix:import namespace=\"http://schemas.xmlsoap.org/wsdl/\" />".$xml."</$schemaPrefix:schema>";
return $xml;
}
function expandQname($qname){
if(strpos($qname,':') &&!ereg('^http://',$qname)){
$name = substr(strstr($qname,':'),1);
$prefix = substr($qname,0,strpos($qname,':'));
if(isset($this->namespaces[$prefix])){
return $this->namespaces[$prefix].':'.$name;
}else {
return $qname;
}
}else {
return $qname;
}
}
function xdebug($string){
$this->debug(' xmlschema: '.$string);
}
function getPHPType($type,$ns){
if(isset($this->typemap[$ns][$type])){
return $this->typemap[$ns][$type];
}elseif(isset($this->complexTypes[$type])){
return $this->complexTypes[$type]['phpType'];
}
return false;
}
function getLocalPart($str){
if($sstr = strrchr($str,':')){
return substr( $sstr,1 );
}else {
return $str;
}
}
function getPrefix($str){
if($pos = strrpos($str,':')){
return substr($str,0,$pos);
}
return false;
}
function getNamespaceFromPrefix($prefix){
if(isset($this->namespaces[$prefix])){
return $this->namespaces[$prefix];
}
return false;
}
function getPrefixFromNamespace($ns){
foreach($this->namespaces as $p =>$n){
if($ns == $n ||$ns == $p){
$this->usedNamespaces[$p] = $n;
return $p;
}
}
return false;
}
function getTypeDef($type){
if(isset($this->complexTypes[$type])){
return $this->complexTypes[$type];
}elseif(isset($this->elements[$type])){
return $this->elements[$type];
}elseif(isset($this->attributes[$type])){
return $this->attributes[$type];
}
return false;
}
function serializeTypeDef($type){
if($typeDef = $this->getTypeDef($type)){
$str .= '<'.$type;
if(is_array($typeDef['attrs'])){
foreach($attrs as $attName =>$data){
$str .= " $attName=\"{type = ".$data['type']."}\"";
}
}
$str .= " xmlns=\"".$this->schema['targetNamespace']."\"";
if(count($typeDef['elements']) >0){
$str .= ">";
foreach($typeDef['elements'] as $element =>$eData){
$str .= $this->serializeTypeDef($element);
}
$str .= "</$type>";
}elseif($typeDef['typeClass'] == 'element') {
$str .= "></$type>";
}else {
$str .= "/>";
}
return $str;
}
return false;
}
function typeToForm($name,$type){
if($typeDef = $this->getTypeDef($type)){
if($typeDef['phpType'] == 'struct'){
$buffer .= '<table>';
foreach($typeDef['elements'] as $child =>$childDef){
$buffer .= "
					<tr><td align='right'>$childDef[name] (type: ".$this->getLocalPart($childDef['type'])."):</td>
					<td><input type='text' name='parameters[".$name."][$childDef[name]]'></td></tr>";
}
$buffer .= '</table>';
}elseif($typeDef['phpType'] == 'array'){
$buffer .= '<table>';
for($i=0;$i <3;$i++){
$buffer .= "
					<tr><td align='right'>array item (type: $typeDef[arrayType]):</td>
					<td><input type='text' name='parameters[".$name."][]'></td></tr>";
}
$buffer .= '</table>';
}else {
$buffer .= "<input type='text' name='parameters[$name]'>";
}
}else {
$buffer .= "<input type='text' name='parameters[$name]'>";
}
return $buffer;
}
function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType=''){
$this->complexTypes[$name] = array(
'name'=>$name,
'typeClass'=>$typeClass,
'phpType'=>$phpType,
'compositor'=>$compositor,
'restrictionBase'=>$restrictionBase,
'elements'=>$elements,
'attrs'=>$attrs,
'arrayType'=>$arrayType
);
}
}
class soapval extends nusoap_base {
function soapval($name='soapval',$type=false,$value=-1,$element_ns=false,$type_ns=false,$attributes=false) {
$this->name = $name;
$this->value = $value;
$this->type = $type;
$this->element_ns = $element_ns;
$this->type_ns = $type_ns;
$this->attributes = $attributes;
}
function serialize($use='encoded') {
return $this->serialize_val($this->value,$this->name,$this->type,$this->element_ns,$this->type_ns,$this->attributes,$use);
}
function decode(){
return $this->value;
}
}
class soap_transport_http extends nusoap_base {
var $url = '';
var $uri = '';
var $scheme = '';
var $host = '';
var $port = '';
var $path = '';
var $request_method = 'POST';
var $protocol_version = '1.0';
var $encoding = '';
var $outgoing_headers = array();
var $incoming_headers = array();
var $outgoing_payload = '';
var $incoming_payload = '';
var $useSOAPAction = true;
var $persistentConnection = false;
var $ch = false;
function soap_transport_http($url){
$this->url = $url;
$u = parse_url($url);
foreach($u as $k =>$v){
$this->debug("$k = $v");
$this->$k = $v;
}
if(isset($u['query']) &&$u['query'] != ''){
$this->path .= '?'.$u['query'];
}
if(!isset($u['port'])){
if($u['scheme'] == 'https'){
$this->port = 443;
}else {
$this->port = 80;
}
}
$this->uri = $this->path;
$this->outgoing_headers['User-Agent'] = $this->title.'/'.$this->version;
if (!isset($u['port'])) {
$this->outgoing_headers['Host'] = $this->host;
}else {
$this->outgoing_headers['Host'] = $this->host.':'.$this->port;
}
if (isset($u['user']) &&$u['user'] != '') {
$this->setCredentials($u['user'],isset($u['pass']) ?$u['pass'] : '');
}
}
function connect($connection_timeout=0,$response_timeout=30){
if ($this->scheme == 'http'||$this->scheme == 'ssl') {
if($this->persistentConnection &&is_resource($this->fp)){
if (!feof($this->fp)) {
$this->debug('Re-use persistent connection');
return true;
}
fclose($this->fp);
$this->debug('Closed persistent connection at EOF');
}
if ($this->scheme == 'ssl') {
$host = 'ssl://'.$this->host;
}else {
$host = $this->host;
}
$this->debug('calling fsockopen with host '.$host);
if($connection_timeout >0){
$this->fp = fsockopen( $host,$this->port,$this->errno,$this->error_str,$connection_timeout);
}else {
$this->fp = fsockopen( $host,$this->port,$this->errno,$this->error_str);
}
if(!$this->fp) {
$this->debug('Couldn\'t open socket connection to server '.$this->url.', Error ('.$this->errno.'): '.$this->error_str);
$this->setError('Couldn\'t open socket connection to server: '.$this->url.', Error ('.$this->errno.'): '.$this->error_str);
return false;
}
socket_set_timeout( $this->fp,$response_timeout);
$this->debug('socket connected');
return true;
}else if ($this->scheme == 'https') {
if (!extension_loaded('curl')) {
$this->setError('CURL Extension, or OpenSSL extension w/ PHP version >= 4.3 is required for HTTPS');
return false;
}
$this->debug('connect using http');
$this->ch = curl_init();
$hostURL = ($this->port != '') ?"https://$this->host:$this->port": "https://$this->host";
$hostURL .= $this->path;
curl_setopt($this->ch,CURLOPT_URL,$hostURL);
curl_setopt($this->ch,CURLOPT_HEADER,1);
curl_setopt($this->ch,CURLOPT_RETURNTRANSFER,1);
if ($this->persistentConnection) {
$this->persistentConnection = false;
$this->outgoing_headers['Connection'] = 'close';
}
if ($connection_timeout != 0) {
curl_setopt($this->ch,CURLOPT_TIMEOUT,$connection_timeout);
}
curl_setopt($this->ch,CURLOPT_SSL_VERIFYPEER,0);
curl_setopt($this->ch,CURLOPT_SSL_VERIFYHOST,0);
$this->debug('cURL connection set up');
return true;
}else {
$this->setError('Unknown scheme '.$this->scheme);
$this->debug('Unknown scheme '.$this->scheme);
return false;
}
}
function send($data,$timeout=0) {
$this->debug('entered send() with data of length: '.strlen($data));
if(!$this->connect($timeout)){
return false;
}
if(!$this->sendRequest($data)){
return false;
}
if(!$data = $this->getResponse()){
return false;
}
$this->debug('end of send()');
return $data;
}
function sendHTTPS($data,$timeout=0) {
return $this->send($data,$timeout);
}
function setCredentials($username,$password) {
$this->outgoing_headers['Authorization'] = ' Basic '.base64_encode($username.':'.$password);
}
function setSOAPAction($soapaction) {
$this->outgoing_headers['SOAPAction'] = $soapaction;
}
function setEncoding($enc='gzip, deflate'){
$this->protocol_version = '1.1';
$this->outgoing_headers['Accept-Encoding'] = $enc;
$this->outgoing_headers['Connection'] = 'close';
$this->persistentConnection = false;
set_magic_quotes_runtime(0);
$this->encoding = $enc;
}
function setProxy($proxyhost,$proxyport,$proxyusername = '',$proxypassword = '') {
$this->uri = $this->url;
$this->host = $proxyhost;
$this->port = $proxyport;
if ($proxyusername != ''&&$proxypassword != '') {
$this->outgoing_headers['Proxy-Authorization'] = ' Basic '.base64_encode($proxyusername.':'.$proxypassword);
}
}
function decodeChunked($buffer){
$length = 0;
$new = '';
$chunkend = strpos($buffer,"\r\n") +2;
$temp = substr($buffer,0,$chunkend);
$chunk_size = hexdec( trim($temp) );
$chunkstart = $chunkend;
while ($chunk_size >0) {
$this->debug("chunkstart: $chunkstart chunk_size: $chunk_size");
$chunkend = strpos( $buffer,"\r\n",$chunkstart +$chunk_size);
if ($chunkend == FALSE) {
$chunk = substr($buffer,$chunkstart);
$new .= $chunk;
$length += strlen($chunk);
break;
}
$chunk = substr($buffer,$chunkstart,$chunkend-$chunkstart);
$new .= $chunk;
$length += strlen($chunk);
$chunkstart = $chunkend +2;
$chunkend = strpos($buffer,"\r\n",$chunkstart)+2;
if ($chunkend == FALSE) {
break;
}
$temp = substr($buffer,$chunkstart,$chunkend-$chunkstart);
$chunk_size = hexdec( trim($temp) );
$chunkstart = $chunkend;
}
return $new;
}
function buildPayload($data) {
$this->outgoing_headers['Content-Length'] = strlen($data);
$this->outgoing_payload = "$this->request_method $this->uri HTTP/$this->protocol_version\r\n";
foreach($this->outgoing_headers as $k =>$v){
if($k == 'SOAPAction'){
$v = '"'.$v.'"';
}
$this->outgoing_payload .= $k.': '.$v."\r\n";
}
$this->outgoing_payload .= "\r\n";
$this->outgoing_payload .= $data;
}
function sendRequest($data){
$this->buildPayload($data);
if ($this->scheme == 'http'||$this->scheme == 'ssl') {
if(!fputs($this->fp,$this->outgoing_payload,strlen($this->outgoing_payload))) {
$this->setError('couldn\'t write message data to socket');
$this->debug('couldn\'t write message data to socket');
return false;
}
$this->debug('wrote data to socket, length = '.strlen($this->outgoing_payload));
return true;
}else if ($this->scheme == 'https') {
curl_setopt($this->ch,CURLOPT_CUSTOMREQUEST,$this->outgoing_payload);
$this->debug('set cURL payload');
return true;
}
}
function getResponse(){
$this->incoming_payload = '';
if ($this->scheme == 'http'||$this->scheme == 'ssl') {
$data = '';
while (!isset($lb)){
if(feof($this->fp)) {
$this->setError('server failed to send headers');
return false;
}
$data .= fgets($this->fp,256);
$pos = strpos($data,"\r\n\r\n");
if($pos >1){
$lb = "\r\n";
}else {
$pos = strpos($data,"\n\n");
if($pos >1){
$lb = "\n";
}
}
if(isset($lb) &&ereg('^HTTP/1.1 100',$data)){
unset($lb);
$data = '';
}
}
$this->incoming_payload .= $data;
$header_data = trim(substr($data,0,$pos));
$header_array = explode($lb,$header_data);
$data = substr($data,$pos);
$this->debug('cleaned data, stringlen: '.strlen($data));
foreach($header_array as $header_line){
$arr = explode(':',$header_line,2);
if(count($arr) >1){
$header_name = strtolower(trim($arr[0]));
$this->incoming_headers[$header_name] = trim($arr[1]);
}else if (isset($header_name)) {
$this->incoming_headers[$header_name] .= $lb .' '.$header_line;
}
}
$strlen = 0;
while ((isset($this->incoming_headers['content-length'])&&$strlen <$this->incoming_headers['content-length']) ||!feof($this->fp)){
$tmp = fread($this->fp,8192);
$strlen += strlen($tmp);
$data .= $tmp;
}
$data = trim($data);
$this->incoming_payload .= $data;
$this->debug('received '.strlen($this->incoming_payload).' bytes of data from server');
if(
(!$this->persistentConnection) ||feof($this->fp)){
fclose($this->fp);
$this->fp = false;
$this->debug('closed socket');
}
if($this->incoming_payload == ''){
$this->setError('no response from server');
return false;
}
$this->debug('received incoming payload: '.strlen($this->incoming_payload));
}else if ($this->scheme == 'https') {
$this->debug('send and receive with cURL');
$this->incoming_payload = curl_exec($this->ch);
$data = $this->incoming_payload;
$cErr = curl_error($this->ch);
if ($cErr != '') {
$err = 'cURL ERROR: '.curl_errno($this->ch).': '.$cErr.'<br>';
foreach(curl_getinfo($this->ch) as $k =>$v){
$err .= "$k: $v<br>";
}
$this->debug($err);
$this->setError($err);
curl_close($this->ch);
return false;
}else {
}
$this->debug('No cURL error, closing cURL');
curl_close($this->ch);
if (ereg('^HTTP/1.1 100',$data)) {
if ($pos = strpos($data,"\r\n\r\n")) {
$data = ltrim(substr($data,$pos));
}elseif($pos = strpos($data,"\n\n") ) {
$data = ltrim(substr($data,$pos));
}
}
if ($pos = strpos($data,"\r\n\r\n")) {
$lb = "\r\n";
}elseif( $pos = strpos($data,"\n\n")) {
$lb = "\n";
}else {
$this->debug('no proper separation of headers and document');
$this->setError('no proper separation of headers and document');
return false;
}
$header_data = trim(substr($data,0,$pos));
$header_array = explode($lb,$header_data);
$data = ltrim(substr($data,$pos));
$this->debug('found proper separation of headers and document');
$this->debug('cleaned data, stringlen: '.strlen($data));
foreach ($header_array as $header_line) {
$arr = explode(':',$header_line,2);
if (count($arr) >1) {
$this->incoming_headers[strtolower(trim($arr[0]))] = trim($arr[1]);
}
}
if (strlen($data) == 0) {
$this->debug('no data after headers!');
$this->setError('no data present after HTTP headers.');
return false;
}
}
if(isset($this->incoming_headers['transfer-encoding']) &&strtolower($this->incoming_headers['transfer-encoding']) == 'chunked'){
if(!$data = $this->decodeChunked($data)){
$this->setError('Decoding of chunked data failed');
return false;
}
}
if(isset($this->incoming_headers['content-encoding']) &&$this->incoming_headers['content-encoding'] != ''){
if(strtolower($this->incoming_headers['content-encoding']) == 'deflate'||strtolower($this->incoming_headers['content-encoding']) == 'gzip'){
if(function_exists('gzuncompress')){
if($this->incoming_headers['content-encoding'] == 'deflate'&&$degzdata = @gzuncompress($data)){
$data = $degzdata;
}elseif($this->incoming_headers['content-encoding'] == 'gzip'&&$degzdata = gzinflate(substr($data,10))){
$data = $degzdata;
}else {
$this->setError('Errors occurred when trying to decode the data');
}
}else {
$this->setError('The server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
}
}
}
if(strlen($data) == 0){
$this->debug('no data after headers!');
$this->setError('no data present after HTTP headers');
return false;
}
$this->incoming_payload = $header_data."\r\n\r\n".$data;
return $data;
}
function setContentType($type,$charset = false) {
$this->outgoing_headers['Content-Type'] = $type .($charset ?'; charset='.$charset : '');
}
function usePersistentConnection(){
if (isset($this->outgoing_headers['Accept-Encoding'])) {
return false;
}
$this->protocol_version = '1.1';
$this->persistentConnection = true;
$this->outgoing_headers['Connection'] = 'Keep-Alive';
return true;
}
}
class soap_server extends nusoap_base {
var $service = '';
var $operations = array();
var $responseHeaders = false;
var $headers = '';
var $request = '';
var $fault = false;
var $result = 'successful';
var $wsdl = false;
var $externalWSDLURL = false;
var $debug_flag = false;
function soap_server($wsdl=false){
global $debug;
global $_REQUEST;
global $_SERVER;
global $HTTP_SERVER_VARS;
if (isset($debug)) {
$this->debug_flag = $debug;
}else if (isset($_REQUEST['debug'])) {
$this->debug_flag = $_REQUEST['debug'];
}else if (isset($_SERVER['QUERY_STRING'])) {
$qs = explode('&',$_SERVER['QUERY_STRING']);
foreach ($qs as $v) {
if (substr($v,0,6) == 'debug=') {
$this->debug_flag = substr($v,6);
}
}
}else if (isset($HTTP_SERVER_VARS['QUERY_STRING'])) {
$qs = explode('&',$HTTP_SERVER_VARS['QUERY_STRING']);
foreach ($qs as $v) {
if (substr($v,0,6) == 'debug=') {
$this->debug_flag = substr($v,6);
}
}
}
if($wsdl){
$this->wsdl = new wsdl($wsdl);
$this->externalWSDLURL = $wsdl;
if($err = $this->wsdl->getError()){
die('WSDL ERROR: '.$err);
}
}
}
function service($data){
global $QUERY_STRING;
if(isset($_SERVER['QUERY_STRING'])){
$qs = $_SERVER['QUERY_STRING'];
}elseif(isset($GLOBALS['QUERY_STRING'])){
$qs = $GLOBALS['QUERY_STRING'];
}elseif(isset($QUERY_STRING) &&$QUERY_STRING != ''){
$qs = $QUERY_STRING;
}
if(isset($qs) &&ereg('wsdl',$qs) ){
if($this->externalWSDLURL){
header('Location: '.$this->externalWSDLURL);
exit();
}else {
header("Content-Type: text/xml\r\n");
print $this->wsdl->serialize();
exit();
}
}
if($data == ''&&$this->wsdl){
print $this->webDescription();
}else {
$response = $this->parse_request($data);
$this->debug('server sending...');
$payload = $response;
if(isset($this->debug_flag) &&$this->debug_flag == 1){
while (strpos($this->debug_str,'--')) {
$this->debug_str = str_replace('--','- -',$this->debug_str);
}
$payload .= "<!--\n".$this->debug_str ."\n-->";
}
if($this->fault){
$header[] = "HTTP/1.0 500 Internal Server Error\r\n";
$header[] = "Status: 500 Internal Server Error\r\n";
}else {
$header[] = "Status: 200 OK\r\n";
}
$header[] = "Server: $this->title Server v$this->version\r\n";
$header[] = "Content-Type: text/xml; charset=$this->soap_defencoding\r\n";
if (isset($this->headers) &&isset($this->headers['Accept-Encoding'])) {
if (strstr($this->headers['Accept-Encoding'],'deflate')) {
if (function_exists('gzcompress')) {
if (isset($this->debug_flag) &&$this->debug_flag) {
$payload .= "<!-- Content being deflated -->";
}
$header[] = "Content-Encoding: deflate";
$payload = gzcompress($payload);
}else {
if (isset($this->debug_flag) &&$this->debug_flag) {
$payload .= "<!-- Content will not be deflated: no gzcompress -->";
}
}
}else if (strstr($this->headers['Accept-Encoding'],'gzip')) {
if (function_exists('gzencode')) {
if (isset($this->debug_flag) &&$this->debug_flag) {
$payload .= "<!-- Content being gzipped -->";
}
$header[] = "Content-Encoding: gzip";
$payload = gzencode($payload);
}else {
if (isset($this->debug_flag) &&$this->debug_flag) {
$payload .= "<!-- Content will not be gzipped: no gzencode -->";
}
}
}
}
$header[] = "Content-Length: ".strlen($payload)."\r\n\r\n";
reset($header);
foreach($header as $hdr){
header($hdr);
}
$this->response = join("\r\n",$header).$payload;
print $payload;
}
}
function parse_request($data='') {
global $HTTP_SERVER_VARS;
$this->debug('entering parseRequest() on '.date('H:i Y-m-d'));
$dump = '';
if(function_exists('getallheaders')){
$this->headers = getallheaders();
foreach($this->headers as $k=>$v){
$dump .= "$k: $v\r\n";
$this->debug("$k: $v");
}
if(isset($this->headers['SOAPAction'])){
$this->SOAPAction = str_replace('"','',$this->headers['SOAPAction']);
}
if(strpos($this->headers['Content-Type'],'=')){
$enc = str_replace('"','',substr(strstr($this->headers["Content-Type"],'='),1));
if(eregi('^(ISO-8859-1|US-ASCII|UTF-8)$',$enc)){
$this->xml_encoding = strtoupper($enc);
}else {
$this->xml_encoding = 'US-ASCII';
}
}else {
$this->xml_encoding = 'UTF-8';
}
}elseif(isset($_SERVER) &&is_array($_SERVER)){
foreach ($_SERVER as $k =>$v) {
if (substr($k,0,5) == 'HTTP_') {
$k = str_replace(' ','-',ucwords(strtolower(str_replace('_',' ',substr($k,5)))));
if ($k == 'Soapaction') {
$k = 'SOAPAction';
$v = str_replace('"','',$v);
$v = str_replace('\\','',$v);
}else if ($k == 'Content-Type') {
if (strpos($v,'=')) {
$enc = substr(strstr($v,'='),1);
$enc = str_replace('"','',$enc);
$enc = str_replace('\\','',$enc);
if (eregi('^(ISO-8859-1|US-ASCII|UTF-8)$',$enc)) {
$this->xml_encoding = strtoupper($enc);
}else {
$this->xml_encoding = 'US-ASCII';
}
}else {
$this->xml_encoding = 'UTF-8';
}
}
$this->headers[$k] = $v;
$dump .= "$k: $v\r\n";
$this->debug("$k: $v");
}
}
}elseif (is_array($HTTP_SERVER_VARS)) {
foreach ($HTTP_SERVER_VARS as $k =>$v) {
if (substr($k,0,5) == 'HTTP_') {
$k = str_replace(' ','-',ucwords(strtolower(str_replace('_',' ',substr($k,5)))));
if ($k == 'Soapaction') {
$k = 'SOAPAction';
$v = str_replace('"','',$v);
$v = str_replace('\\','',$v);
}else if ($k == 'Content-Type') {
if (strpos($v,'=')) {
$enc = substr(strstr($v,'='),1);
$enc = str_replace('"','',$enc);
$enc = str_replace('\\','',$enc);
if (eregi('^(ISO-8859-1|US-ASCII|UTF-8)$',$enc)) {
$this->xml_encoding = strtoupper($enc);
}else {
$this->xml_encoding = 'US-ASCII';
}
}else {
$this->xml_encoding = 'UTF-8';
}
}
$this->headers[$k] = $v;
$dump .= "$k: $v\r\n";
$this->debug("$k: $v");
}
}
}
$this->debug('got character encoding: '.$this->xml_encoding);
if (isset($this->headers['Content-Encoding']) &&$this->headers['Content-Encoding'] != '') {
$this->debug('got content encoding: '.$this->headers['Content-Encoding']);
if ($this->headers['Content-Encoding'] == 'deflate'||$this->headers['Content-Encoding'] == 'gzip') {
if (function_exists('gzuncompress')) {
if ($this->headers['Content-Encoding'] == 'deflate'&&$degzdata = @gzuncompress($data)) {
$data = $degzdata;
}elseif ($this->headers['Content-Encoding'] == 'gzip'&&$degzdata = gzinflate(substr($data,10))) {
$data = $degzdata;
}else {
$this->fault('Server','Errors occurred when trying to decode the data');
return $this->fault->serialize();
}
}else {
$this->fault('Server','This Server does not support compressed data');
return $this->fault->serialize();
}
}
}
$this->request = $dump."\r\n\r\n".$data;
$parser = new soap_parser($data,$this->xml_encoding);
if($err = $parser->getError()){
$this->debug("parser debug: \n".$parser->debug_str);
$this->result = 'fault: error in msg parsing: '.$err;
$this->fault('Server',"error in msg parsing:\n".$err);
return $this->fault->serialize();
}else {
$this->methodname = $parser->root_struct_name;
$this->debug('method name: '.$this->methodname);
if(!function_exists($this->methodname)){
$this->debug("method '$this->methodname' not found!");
$this->debug("parser debug: \n".$parser->debug_str);
$this->result = 'fault: method not found';
$this->fault('Server',"method '$this->methodname' not defined in service '$this->service'");
return $this->fault->serialize();
}
if($this->wsdl){
if(!$this->opData = $this->wsdl->getOperationData($this->methodname)){
$this->fault('Server',"Operation '$this->methodname' is not defined in the WSDL for this service");
return $this->fault->serialize();
}
}
$this->debug("method '$this->methodname' exists");
$this->debug('calling parser->get_response()');
$request_data = $parser->get_response();
$this->debug("parser debug: \n".$parser->debug_str);
if($this->verify_method($this->methodname,$request_data)){
$this->debug('params var dump '.$this->varDump($request_data));
if($request_data){
$this->debug("calling '$this->methodname' with params");
if (!function_exists('call_user_func_array')) {
$this->debug('calling method using eval()');
$funcCall = $this->methodname.'(';
foreach($request_data as $param) {
$funcCall .= "\"$param\",";
}
$funcCall = substr($funcCall,0,-1).')';
$this->debug('function call:<br>'.$funcCall);
@eval("\$method_response = $funcCall;");
}else {
$this->debug('calling method using call_user_func_array()');
$method_response = call_user_func_array("$this->methodname",$request_data);
}
$this->debug('response var dump'.$this->varDump($method_response));
}else {
$this->debug("calling $this->methodname w/ no params");
$m = $this->methodname;
$method_response = @$m();
}
$this->debug("done calling method: $this->methodname, received $method_response of type".gettype($method_response));
if(isset($method_response) &&$method_response != ''||is_bool($method_response)) {
if(get_class($method_response) == 'soap_fault'){
$this->debug('got a fault object from method');
$this->fault = $method_response;
return $method_response->serialize();
}elseif(get_class($method_response) == 'soapval'){
$this->debug('got a soapval object from method');
$return_val = $method_response->serialize();
}else {
$this->debug('got a(n) '.gettype($method_response).' from method');
$this->debug('serializing return value');
if($this->wsdl){
if(sizeof($this->opData['output']['parts']) >1){
$opParams = $method_response;
}else {
$opParams = array($method_response);
}
$return_val = $this->wsdl->serializeRPCParameters($this->methodname,'output',$opParams);
}else {
$return_val = $this->serialize_val($method_response);
}
}
$this->debug('return val:'.$this->varDump($return_val));
}else {
$return_val = '';
$this->debug('got no response from method');
}
$this->debug('serializing response');
$payload = '<'.$this->methodname."Response>".$return_val.'</'.$this->methodname."Response>";
$this->result = 'successful';
if($this->wsdl){
$this->debug("WSDL debug data:\n".$this->wsdl->debug_str);
return $this->serializeEnvelope($payload,$this->responseHeaders,$this->wsdl->usedNamespaces,$this->opData['style']);
}else {
return $this->serializeEnvelope($payload,$this->responseHeaders);
}
}else {
$this->debug('ERROR: request not verified against method signature');
$this->result = 'fault: request failed validation against method signature';
$this->fault('Server',"Operation '$this->methodname' not defined in service.");
return $this->fault->serialize();
}
}
}
function verify_method($operation,$request){
if(isset($this->wsdl) &&is_object($this->wsdl)){
if($this->wsdl->getOperationData($operation)){
return true;
}
}elseif(isset($this->operations[$operation])){
return true;
}
return false;
}
function add_to_map($methodname,$in,$out){
$this->operations[$methodname] = array('name'=>$methodname,'in'=>$in,'out'=>$out);
}
function register($name,$in=false,$out=false,$namespace=false,$soapaction=false,$style=false,$use=false,$documentation=''){
if($this->externalWSDLURL){
die('You cannot bind to an external WSDL file, and register methods outside of it! Please choose either WSDL or no WSDL.');
}
if(false == $in) {
}
if(false == $out) {
}
if(false == $namespace) {
}
if(false == $soapaction) {
global $SERVER_NAME,$SCRIPT_NAME;
$soapaction = "http://$SERVER_NAME$SCRIPT_NAME";
}
if(false == $style) {
$style = "rpc";
}
if(false == $use) {
$use = "encoded";
}
$this->operations[$name] = array(
'name'=>$name,
'in'=>$in,
'out'=>$out,
'namespace'=>$namespace,
'soapaction'=>$soapaction,
'style'=>$style);
if($this->wsdl){
$this->wsdl->addOperation($name,$in,$out,$namespace,$soapaction,$style,$use,$documentation);
}
return true;
}
function fault($faultcode,$faultactor,$faultstring='',$faultdetail=''){
$this->fault = new soap_fault($faultcode,$faultactor,$faultstring,$faultdetail);
}
function webDescription(){
$b = '
		<html><head><title>NuSOAP: '.$this->wsdl->serviceName.'</title>
		<style type="text/css">
		    body    { font-family: arial; color: #000000; background-color: #ffffff; margin: 0px 0px 0px 0px; }
		    p       { font-family: arial; color: #000000; margin-top: 0px; margin-bottom: 12px; }
		    pre { background-color: silver; padding: 5px; font-family: Courier New; font-size: x-small; color: #000000;}
		    ul      { margin-top: 10px; margin-left: 20px; }
		    li      { list-style-type: none; margin-top: 10px; color: #000000; }
		    .content{
			margin-left: 0px; padding-bottom: 2em; }
		    .nav {
			padding-top: 10px; padding-bottom: 10px; padding-left: 15px; font-size: .70em;
			margin-top: 10px; margin-left: 0px; color: #000000;
			background-color: #ccccff; width: 20%; margin-left: 20px; margin-top: 20px; }
		    .title {
			font-family: arial; font-size: 26px; color: #ffffff;
			background-color: #999999; width: 105%; margin-left: 0px;
			padding-top: 10px; padding-bottom: 10px; padding-left: 15px;}
		    .hidden {
			position: absolute; visibility: hidden; z-index: 200; left: 250px; top: 100px;
			font-family: arial; overflow: hidden; width: 600;
			padding: 20px; font-size: 10px; background-color: #999999;
			layer-background-color:#FFFFFF; }
		    a,a:active  { color: charcoal; font-weight: bold; }
		    a:visited   { color: #666666; font-weight: bold; }
		    a:hover     { color: cc3300; font-weight: bold; }
		</style>
		<script language="JavaScript" type="text/javascript">
		<!--
		// POP-UP CAPTIONS...
		function lib_bwcheck(){ //Browsercheck (needed)
		    this.ver=navigator.appVersion
		    this.agent=navigator.userAgent
		    this.dom=document.getElementById?1:0
		    this.opera5=this.agent.indexOf("Opera 5")>-1
		    this.ie5=(this.ver.indexOf("MSIE 5")>-1 && this.dom && !this.opera5)?1:0;
		    this.ie6=(this.ver.indexOf("MSIE 6")>-1 && this.dom && !this.opera5)?1:0;
		    this.ie4=(document.all && !this.dom && !this.opera5)?1:0;
		    this.ie=this.ie4||this.ie5||this.ie6
		    this.mac=this.agent.indexOf("Mac")>-1
		    this.ns6=(this.dom && parseInt(this.ver) >= 5) ?1:0;
		    this.ns4=(document.layers && !this.dom)?1:0;
		    this.bw=(this.ie6 || this.ie5 || this.ie4 || this.ns4 || this.ns6 || this.opera5)
		    return this
		}
		var bw = new lib_bwcheck()
		//Makes crossbrowser object.
		function makeObj(obj){
		    this.evnt=bw.dom? document.getElementById(obj):bw.ie4?document.all[obj]:bw.ns4?document.layers[obj]:0;
		    if(!this.evnt) return false
		    this.css=bw.dom||bw.ie4?this.evnt.style:bw.ns4?this.evnt:0;
		    this.wref=bw.dom||bw.ie4?this.evnt:bw.ns4?this.css.document:0;
		    this.writeIt=b_writeIt;
		    return this
		}
		// A unit of measure that will be added when setting the position of a layer.
		//var px = bw.ns4||window.opera?"":"px";
		function b_writeIt(text){
		    if (bw.ns4){this.wref.write(text);this.wref.close()}
		    else this.wref.innerHTML = text
		}
		//Shows the messages
		var oDesc;
		function popup(divid){
		    if(oDesc = new makeObj(divid)){
			oDesc.css.visibility = "visible"
		    }
		}
		function popout(){ // Hides message
		    if(oDesc) oDesc.css.visibility = "hidden"
		}
		//-->
		</script>
		</head>
		<body>
		<div class=content>
			<br><br>
			<div class=title>'.$this->wsdl->serviceName.'</div>
			<div class=nav>
				<p>View the <a href="'.(isset($GLOBALS['PHP_SELF']) ?$GLOBALS['PHP_SELF'] : $_SERVER['PHP_SELF']).'?wsdl">WSDL</a> for the service.
				Click on an operation name to view it&apos;s details.</p>
				<ul>';
foreach($this->wsdl->getOperations() as $op =>$data){
$b .= "<li><a href='#' onclick=\"popup('$op')\">$op</a></li>";
$b .= "<div id='$op' class='hidden'>
				    <a href='#' onclick='popout()'><font color='#ffffff'>Close</font></a><br><br>";
foreach($data as $donnie =>$marie){
if($donnie == 'input'||$donnie == 'output'){
$b .= "<font color='white'>".ucfirst($donnie).':</font><br>';
foreach($marie as $captain =>$tenille){
if($captain == 'parts'){
$b .= "&nbsp;&nbsp;$captain:<br>";
foreach($tenille as $joanie =>$chachi){
$b .= "&nbsp;&nbsp;&nbsp;&nbsp;$joanie: $chachi<br>";
}
}else {
$b .= "&nbsp;&nbsp;$captain: $tenille<br>";
}
}
}else {
$b .= "<font color='white'>".ucfirst($donnie).":</font> $marie<br>";
}
}
$b .= '</div>';
}
$b .= '
				<ul>
			</div>
		</div></body></html>';
return $b;
}
function configureWSDL($serviceName,$namespace = false,$endpoint = false,$style='rpc',$transport = 'http://schemas.xmlsoap.org/soap/http')
{
$SERVER_NAME = isset($_SERVER['SERVER_NAME']) ?$_SERVER['SERVER_NAME'] : $GLOBALS['SERVER_NAME'];
$SCRIPT_NAME = isset($_SERVER['SCRIPT_NAME']) ?$_SERVER['SCRIPT_NAME'] : $GLOBALS['SCRIPT_NAME'];
if(false == $namespace) {
$namespace = "http://$SERVER_NAME/soap/$serviceName";
}
if(false == $endpoint) {
$endpoint = "http://$SERVER_NAME$SCRIPT_NAME";
}
$this->wsdl = new wsdl;
$this->wsdl->serviceName = $serviceName;
$this->wsdl->endpoint = $endpoint;
$this->wsdl->namespaces['tns'] = $namespace;
$this->wsdl->namespaces['soap'] = 'http://schemas.xmlsoap.org/wsdl/soap/';
$this->wsdl->namespaces['wsdl'] = 'http://schemas.xmlsoap.org/wsdl/';
$this->wsdl->bindings[$serviceName.'Binding'] = array(
'name'=>$serviceName.'Binding',
'style'=>$style,
'transport'=>$transport,
'portType'=>$serviceName.'PortType');
$this->wsdl->ports[$serviceName.'Port'] = array(
'binding'=>$serviceName.'Binding',
'location'=>$endpoint,
'bindingType'=>'http://schemas.xmlsoap.org/wsdl/soap/');
}
}
class wsdl extends XMLSchema {
var $wsdl;
var $message = array();
var $complexTypes = array();
var $messages = array();
var $currentMessage;
var $currentOperation;
var $portTypes = array();
var $currentPortType;
var $bindings = array();
var $currentBinding;
var $ports = array();
var $currentPort;
var $opData = array();
var $status = '';
var $documentation = false;
var $endpoint = '';
var $import = array();
var $parser;
var $position = 0;
var $depth = 0;
var $depth_array = array();
var $usedNamespaces = array();
var $proxyhost = '';
var $proxyport = '';
var $proxyusername = '';
var $proxypassword = '';
function wsdl($wsdl = '',$proxyhost=false,$proxyport=false,$proxyusername=false,$proxypassword=false){
$this->wsdl = $wsdl;
$this->proxyhost = $proxyhost;
$this->proxyport = $proxyport;
$this->proxyusername = $proxyusername;
$this->proxypassword = $proxypassword;
if ($wsdl != "") {
$this->debug('initial wsdl file: '.$wsdl);
$this->parseWSDL($wsdl);
}
if (sizeof($this->import) >0) {
$wsdlparts = parse_url($this->wsdl);
foreach ($this->import as $ns =>$list) {
foreach ($list as $url) {
if ($url != '') {
$urlparts = parse_url($url);
if (!isset($urlparts['host'])) {
$url = $wsdlparts['scheme'] .'://'.$wsdlparts['host'] .
substr($wsdlparts['path'],0,strrpos($wsdlparts['path'],'/') +1) .$urlparts['path'];
}
$this->parseWSDL($url);
}else {
$this->namespaces['ns'.(count($this->namespaces)+1)] = $ns;
}
}
}
}
}
function parseWSDL($wsdl = '')
{
if ($wsdl == '') {
$this->debug('no wsdl passed to parseWSDL()!!');
$this->setError('no wsdl passed to parseWSDL()!!');
return false;
}
$wsdl_props = parse_url($wsdl);
if (isset($wsdl_props['host'])) {
$this->debug('getting URL '.$wsdl);
$tr = new soap_transport_http($wsdl);
$tr->request_method = 'GET';
$tr->useSOAPAction = false;
if($this->proxyhost &&$this->proxyport){
$tr->setProxy($this->proxyhost,$this->proxyport,$this->proxyusername,$this->proxypassword);
}
if (isset($wsdl_props['user'])) {
$tr->setCredentials($wsdl_props['user'],$wsdl_props['pass']);
}
$wsdl_string = $tr->send('');
$this->debug("WSDL request\n".$tr->outgoing_payload);
$this->debug("WSDL response\n".$tr->incoming_payload);
$this->debug("transport debug data...\n".$tr->debug_str);
if($err = $tr->getError() ){
$this->debug('HTTP ERROR: '.$err);
$this->setError('HTTP ERROR: '.$err);
unset($tr);
return false;
}
unset($tr);
}else {
$this->debug('getting FILE '.$wsdl);
if ($fp = @fopen($wsdl,'r')) {
$wsdl_string = '';
while ($data = fread($fp,32768)) {
$wsdl_string .= $data;
}
fclose($fp);
}else {
$this->setError('bad path to WSDL file.');
return false;
}
}
$this->parser = xml_parser_create();
xml_parser_set_option($this->parser,XML_OPTION_CASE_FOLDING,0);
xml_set_object($this->parser,$this);
xml_set_element_handler($this->parser,'start_element','end_element');
xml_set_character_data_handler($this->parser,'character_data');
if (!xml_parse($this->parser,$wsdl_string,true)) {
$errstr = sprintf(
'XML error on line %d: %s',
xml_get_current_line_number($this->parser),
xml_error_string(xml_get_error_code($this->parser))
);
$this->debug('XML parse error: '.$errstr);
$this->setError('Parser error: '.$errstr);
return false;
}
xml_parser_free($this->parser);
if($this->getError()){
return false;
}
foreach($this->bindings as $binding =>$bindingData) {
if (isset($bindingData['operations']) &&is_array($bindingData['operations'])) {
foreach($bindingData['operations'] as $operation =>$data) {
$this->debug('post-parse data gathering for '.$operation);
$this->bindings[$binding]['operations'][$operation]['input'] = 
isset($this->bindings[$binding]['operations'][$operation]['input']) ?
array_merge($this->bindings[$binding]['operations'][$operation]['input'],$this->portTypes[$bindingData['portType'] ][$operation]['input']) :
$this->portTypes[$bindingData['portType'] ][$operation]['input'];
$this->bindings[$binding]['operations'][$operation]['output'] = 
isset($this->bindings[$binding]['operations'][$operation]['output']) ?
array_merge($this->bindings[$binding]['operations'][$operation]['output'],$this->portTypes[$bindingData['portType'] ][$operation]['output']) :
$this->portTypes[$bindingData['portType'] ][$operation]['output'];
if(isset($this->messages[$this->bindings[$binding]['operations'][$operation]['input']['message'] ])){
$this->bindings[$binding]['operations'][$operation]['input']['parts'] = $this->messages[$this->bindings[$binding]['operations'][$operation]['input']['message'] ];
}
if(isset($this->messages[$this->bindings[$binding]['operations'][$operation]['output']['message'] ])){
$this->bindings[$binding]['operations'][$operation]['output']['parts'] = $this->messages[$this->bindings[$binding]['operations'][$operation]['output']['message'] ];
}
if (isset($bindingData['style'])) {
$this->bindings[$binding]['operations'][$operation]['style'] = $bindingData['style'];
}
$this->bindings[$binding]['operations'][$operation]['transport'] = isset($bindingData['transport']) ?$bindingData['transport'] : '';
$this->bindings[$binding]['operations'][$operation]['documentation'] = isset($this->portTypes[$bindingData['portType'] ][$operation]['documentation']) ?$this->portTypes[$bindingData['portType'] ][$operation]['documentation'] : '';
$this->bindings[$binding]['operations'][$operation]['endpoint'] = isset($bindingData['endpoint']) ?$bindingData['endpoint'] : '';
}
}
}
return true;
}
function start_element($parser,$name,$attrs)
{
if ($this->status == 'schema'||ereg('schema$',$name)) {
$this->status = 'schema';
$this->schemaStartElement($parser,$name,$attrs);
}else {
$pos = $this->position++;
$depth = $this->depth++;
$this->depth_array[$depth] = $pos;
$this->message[$pos] = array('cdata'=>'');
if (ereg(':',$name)) {
$prefix = substr($name,0,strpos($name,':'));
$namespace = isset($this->namespaces[$prefix]) ?$this->namespaces[$prefix] : '';
$name = substr(strstr($name,':'),1);
}
if (count($attrs) >0) {
foreach($attrs as $k =>$v) {
if (ereg("^xmlns",$k)) {
if ($ns_prefix = substr(strrchr($k,':'),1)) {
$this->namespaces[$ns_prefix] = $v;
}else {
$this->namespaces['ns'.(count($this->namespaces) +1)] = $v;
}
if ($v == 'http://www.w3.org/2001/XMLSchema'||$v == 'http://www.w3.org/1999/XMLSchema') {
$this->XMLSchemaVersion = $v;
$this->namespaces['xsi'] = $v .'-instance';
}
}
$k = strpos($k,':') ?$this->expandQname($k) : $k;
if ($k != 'location'&&$k != 'soapAction'&&$k != 'namespace') {
$v = strpos($v,':') ?$this->expandQname($v) : $v;
}
$eAttrs[$k] = $v;
}
$attrs = $eAttrs;
}else {
$attrs = array();
}
switch ($this->status) {
case 'message':
if ($name == 'part') {
if (isset($attrs['type'])) {
$this->debug("msg ".$this->currentMessage .": found part $attrs[name]: ".implode(',',$attrs));
$this->messages[$this->currentMessage][$attrs['name']] = $attrs['type'];
}
if (isset($attrs['element'])) {
$this->messages[$this->currentMessage][$attrs['name']] = $attrs['element'];
}
}
break;
case 'portType':
switch ($name) {
case 'operation':
$this->currentPortOperation = $attrs['name'];
$this->debug("portType $this->currentPortType operation: $this->currentPortOperation");
if (isset($attrs['parameterOrder'])) {
$this->portTypes[$this->currentPortType][$attrs['name']]['parameterOrder'] = $attrs['parameterOrder'];
}
break;
case 'documentation':
$this->documentation = true;
break;
default:
$m = isset($attrs['message']) ?$this->getLocalPart($attrs['message']) : '';
$this->portTypes[$this->currentPortType][$this->currentPortOperation][$name]['message'] = $m;
break;
}
break;
case 'binding':
switch ($name) {
case 'binding': 
if (isset($attrs['style'])) {
$this->bindings[$this->currentBinding]['prefix'] = $prefix;
}
$this->bindings[$this->currentBinding] = array_merge($this->bindings[$this->currentBinding],$attrs);
break;
case 'header':
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation][$this->opStatus]['headers'][] = $attrs;
break;
case 'operation':
if (isset($attrs['soapAction'])) {
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation]['soapAction'] = $attrs['soapAction'];
}
if (isset($attrs['style'])) {
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation]['style'] = $attrs['style'];
}
if (isset($attrs['name'])) {
$this->currentOperation = $attrs['name'];
$this->debug("current binding operation: $this->currentOperation");
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation]['name'] = $attrs['name'];
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation]['binding'] = $this->currentBinding;
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation]['endpoint'] = isset($this->bindings[$this->currentBinding]['endpoint']) ?$this->bindings[$this->currentBinding]['endpoint'] : '';
}
break;
case 'input':
$this->opStatus = 'input';
break;
case 'output':
$this->opStatus = 'output';
break;
case 'body':
if (isset($this->bindings[$this->currentBinding]['operations'][$this->currentOperation][$this->opStatus])) {
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation][$this->opStatus] = array_merge($this->bindings[$this->currentBinding]['operations'][$this->currentOperation][$this->opStatus],$attrs);
}else {
$this->bindings[$this->currentBinding]['operations'][$this->currentOperation][$this->opStatus] = $attrs;
}
break;
}
break;
case 'service':
switch ($name) {
case 'port':
$this->currentPort = $attrs['name'];
$this->debug('current port: '.$this->currentPort);
$this->ports[$this->currentPort]['binding'] = $this->getLocalPart($attrs['binding']);
break;
case 'address':
$this->ports[$this->currentPort]['location'] = $attrs['location'];
$this->ports[$this->currentPort]['bindingType'] = $namespace;
$this->bindings[$this->ports[$this->currentPort]['binding'] ]['bindingType'] = $namespace;
$this->bindings[$this->ports[$this->currentPort]['binding'] ]['endpoint'] = $attrs['location'];
break;
}
break;
}
switch ($name) {
case "import":
if (isset($attrs['location'])) {
$this->import[$attrs['namespace']][] = $attrs['location'];
$this->debug('parsing import '.$attrs['namespace'].' - '.$attrs['location'] .' ('.count($this->import[$attrs['namespace']]).')');
}
break;
case 'types':
$this->status = 'schema';
break;
case 'message':
$this->status = 'message';
$this->messages[$attrs['name']] = array();
$this->currentMessage = $attrs['name'];
break;
case 'portType':
$this->status = 'portType';
$this->portTypes[$attrs['name']] = array();
$this->currentPortType = $attrs['name'];
break;
case "binding":
if (isset($attrs['name'])) {
if (strpos($attrs['name'],':')) {
$this->currentBinding = $this->getLocalPart($attrs['name']);
}else {
$this->currentBinding = $attrs['name'];
}
$this->status = 'binding';
$this->bindings[$this->currentBinding]['portType'] = $this->getLocalPart($attrs['type']);
$this->debug("current binding: $this->currentBinding of portType: ".$attrs['type']);
}
break;
case 'service':
$this->serviceName = $attrs['name'];
$this->status = 'service';
$this->debug('current service: '.$this->serviceName);
break;
case 'definitions':
foreach ($attrs as $name =>$value) {
$this->wsdl_info[$name] = $value;
}
break;
}
}
}
function end_element($parser,$name){
if (ereg('types$',$name) ||ereg('schema$',$name)) {
$this->status = "";
}
if ($this->status == 'schema') {
$this->schemaEndElement($parser,$name);
}else {
$this->depth--;
}
if ($this->documentation) {
$this->portTypes[$this->currentPortType][$this->currentPortOperation]['documentation'] = $this->documentation;
$this->documentation = false;
}
}
function character_data($parser,$data)
{
$pos = isset($this->depth_array[$this->depth]) ?$this->depth_array[$this->depth] : 0;
if (isset($this->message[$pos]['cdata'])) {
$this->message[$pos]['cdata'] .= $data;
}
if ($this->documentation) {
$this->documentation .= $data;
}
}
function getBindingData($binding)
{
if (is_array($this->bindings[$binding])) {
return $this->bindings[$binding];
}
}
function getOperations($bindingType = 'soap')
{
$ops = array();
if ($bindingType == 'soap') {
$bindingType = 'http://schemas.xmlsoap.org/wsdl/soap/';
}
foreach($this->ports as $port =>$portData) {
if ($portData['bindingType'] == $bindingType) {
$ops = array_merge ($ops,$this->bindings[$portData['binding'] ]['operations']);
}
}
return $ops;
}
function getOperationData($operation,$bindingType = 'soap')
{
if ($bindingType == 'soap') {
$bindingType = 'http://schemas.xmlsoap.org/wsdl/soap/';
}
foreach($this->ports as $port =>$portData) {
if ($portData['bindingType'] == $bindingType) {
foreach(array_keys($this->bindings[$portData['binding'] ]['operations']) as $bOperation) {
if ($operation == $bOperation) {
$opData = $this->bindings[$portData['binding'] ]['operations'][$operation];
return $opData;
}
}
}
}
}
function serialize()
{
$xml = '<?xml version="1.0"?><definitions';
foreach($this->namespaces as $k =>$v) {
$xml .= " xmlns:$k=\"$v\"";
}
if (isset($this->namespaces['wsdl'])) {
$xml .= " xmlns=\"".$this->namespaces['wsdl'] ."\"";
}
if (isset($this->namespaces['tns'])) {
$xml .= " targetNamespace=\"".$this->namespaces['tns'] ."\"";
}
$xml .= '>';
if (sizeof($this->import) >0) {
foreach($this->import as $ns =>$url) {
$xml .= '<import location="'.$url .'" namespace="'.$ns .'" />';
}
}
if (count($this->complexTypes)>=1) {
$xml .= '<types>';
$xml .= $this->serializeSchema();
$xml .= '</types>';
}
if (count($this->messages) >= 1) {
foreach($this->messages as $msgName =>$msgParts) {
$xml .= '<message name="'.$msgName .'">';
if(is_array($msgParts)){
foreach($msgParts as $partName =>$partType) {
if (strpos($partType,':')) {
$typePrefix = $this->getPrefixFromNamespace($this->getPrefix($partType));
}elseif (isset($this->typemap[$this->namespaces['xsd']][$partType])) {
$typePrefix = 'xsd';
}else {
foreach($this->typemap as $ns =>$types) {
if (isset($types[$partType])) {
$typePrefix = $this->getPrefixFromNamespace($ns);
}
}
if (!isset($typePrefix)) {
die("$partType has no namespace!");
}
}
$xml .= '<part name="'.$partName .'" type="'.$typePrefix .':'.$this->getLocalPart($partType) .'" />';
}
}
$xml .= '</message>';
}
}
if (count($this->bindings) >= 1) {
$binding_xml = '';
$portType_xml = '';
foreach($this->bindings as $bindingName =>$attrs) {
$binding_xml .= '<binding name="'.$bindingName .'" type="tns:'.$attrs['portType'] .'">';
$binding_xml .= '<soap:binding style="'.$attrs['style'] .'" transport="'.$attrs['transport'] .'"/>';
$portType_xml .= '<portType name="'.$attrs['portType'] .'">';
foreach($attrs['operations'] as $opName =>$opParts) {
$binding_xml .= '<operation name="'.$opName .'">';
$binding_xml .= '<soap:operation soapAction="'.$opParts['soapAction'] .'" style="'.$attrs['style'] .'"/>';
if (isset($opParts['input']['encodingStyle']) &&$opParts['input']['encodingStyle'] != '') {
$enc_style = '" encodingStyle="'.$opParts['input']['encodingStyle'] .'"';
}else {
$enc_style = '';
}
$binding_xml .= '<input><soap:body use="'.$opParts['input']['use'] .'" namespace="'.$opParts['input']['namespace'] .$enc_style .'/></input>';
if (isset($opParts['output']['encodingStyle']) &&$opParts['output']['encodingStyle'] != '') {
$enc_style = '" encodingStyle="'.$opParts['output']['encodingStyle'] .'"';
}else {
$enc_style = '';
}
$binding_xml .= '<output><soap:body use="'.$opParts['output']['use'] .'" namespace="'.$opParts['output']['namespace'] .$enc_style .'/></output>';
$binding_xml .= '</operation>';
$portType_xml .= '<operation name="'.$opParts['name'] .'"';
if (isset($opParts['parameterOrder'])) {
$portType_xml .= ' parameterOrder="'.$opParts['parameterOrder'] .'"';
}
$portType_xml .= '>';
if(isset($opParts['documentation']) &&$opParts['documentation'] != '') {
$portType_xml .= '<documentation>'.htmlspecialchars($opParts['documentation']) .'</documentation>';
}
$portType_xml .= '<input message="tns:'.$opParts['input']['message'] .'"/>';
$portType_xml .= '<output message="tns:'.$opParts['output']['message'] .'"/>';
$portType_xml .= '</operation>';
}
$portType_xml .= '</portType>';
$binding_xml .= '</binding>';
}
$xml .= $portType_xml .$binding_xml;
}
$xml .= '<service name="'.$this->serviceName .'">';
if (count($this->ports) >= 1) {
foreach($this->ports as $pName =>$attrs) {
$xml .= '<port name="'.$pName .'" binding="tns:'.$attrs['binding'] .'">';
$xml .= '<soap:address location="'.$attrs['location'] .'"/>';
$xml .= '</port>';
}
}
$xml .= '</service>';
return $xml .'</definitions>';
}
function serializeRPCParameters($operation,$direction,$parameters)
{
$this->debug('in serializeRPCParameters with operation '.$operation.', direction '.$direction.' and '.count($parameters).' param(s), and xml schema version '.$this->XMLSchemaVersion);
if ($direction != 'input'&&$direction != 'output') {
$this->debug('The value of the \$direction argument needs to be either "input" or "output"');
$this->setError('The value of the \$direction argument needs to be either "input" or "output"');
return false;
}
if (!$opData = $this->getOperationData($operation)) {
$this->debug('Unable to retrieve WSDL data for operation: '.$operation);
$this->setError('Unable to retrieve WSDL data for operation: '.$operation);
return false;
}
$this->debug($this->varDump($opData));
$encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/';
if(($direction == 'input') &&isset($opData['output']['encodingStyle']) &&($opData['output']['encodingStyle'] != $encodingStyle)) {
$encodingStyle = $opData['output']['encodingStyle'];
$enc_style = $encodingStyle;
}
$xml = '';
if (isset($opData[$direction]['parts']) &&sizeof($opData[$direction]['parts']) >0) {
$use = $opData[$direction]['use'];
$this->debug("use=$use");
$this->debug('got '.count($opData[$direction]['parts']) .' part(s)');
foreach($opData[$direction]['parts'] as $name =>$type) {
$this->debug('serializing part "'.$name.'" of type "'.$type.'"');
if (isset($opData[$direction]['encodingStyle']) &&$encodingStyle != $opData[$direction]['encodingStyle']) {
$encodingStyle = $opData[$direction]['encodingStyle'];
$enc_style = $encodingStyle;
}else {
$enc_style = false;
}
if (isset($parameters[$name])) {
$this->debug('calling serializeType w/ named param');
$xml .= $this->serializeType($name,$type,$parameters[$name],$use,$enc_style);
}elseif(is_array($parameters)) {
$this->debug('calling serializeType w/ unnamed param');
$xml .= $this->serializeType($name,$type,array_shift($parameters),$use,$enc_style);
}else {
$this->debug('no parameters passed.');
}
}
}
return $xml;
}
function serializeParameters($operation,$direction,$parameters)
{
$this->debug('in serializeParameters with operation '.$operation.', direction '.$direction.' and '.count($parameters).' param(s), and xml schema version '.$this->XMLSchemaVersion);
if ($direction != 'input'&&$direction != 'output') {
$this->debug('The value of the \$direction argument needs to be either "input" or "output"');
$this->setError('The value of the \$direction argument needs to be either "input" or "output"');
return false;
}
if (!$opData = $this->getOperationData($operation)) {
$this->debug('Unable to retrieve WSDL data for operation: '.$operation);
$this->setError('Unable to retrieve WSDL data for operation: '.$operation);
return false;
}
$this->debug($this->varDump($opData));
$encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/';
if(($direction == 'input') &&isset($opData['output']['encodingStyle']) &&($opData['output']['encodingStyle'] != $encodingStyle)) {
$encodingStyle = $opData['output']['encodingStyle'];
$enc_style = $encodingStyle;
}
$xml = '';
if (isset($opData[$direction]['parts']) &&sizeof($opData[$direction]['parts']) >0) {
$use = $opData[$direction]['use'];
$this->debug("use=$use");
$this->debug('got '.count($opData[$direction]['parts']) .' part(s)');
foreach($opData[$direction]['parts'] as $name =>$type) {
$this->debug('serializing part "'.$name.'" of type "'.$type.'"');
if(isset($opData[$direction]['encodingStyle']) &&$encodingStyle != $opData[$direction]['encodingStyle']) {
$encodingStyle = $opData[$direction]['encodingStyle'];
$enc_style = $encodingStyle;
}else {
$enc_style = false;
}
if (isset($parameters[$name])) {
$this->debug('calling serializeType w/ named param');
$xml .= $this->serializeType($name,$type,$parameters[$name],$use,$enc_style);
}elseif(is_array($parameters)) {
$this->debug('calling serializeType w/ unnamed param');
$xml .= $this->serializeType($name,$type,array_shift($parameters),$use,$enc_style);
}else {
$this->debug('no parameters passed.');
}
}
}
return $xml;
}
function serializeType($name,$type,$value,$use='encoded',$encodingStyle=false)
{
$this->debug("in serializeType: $name, $type, $value, $use, $encodingStyle");
if($use == 'encoded'&&$encodingStyle) {
$encodingStyle = ' SOAP:encodingStyle="'.$encodingStyle .'"';
}
$xml = '';
if (strpos($type,':')) {
$uqType = substr($type,strrpos($type,':') +1);
$ns = substr($type,0,strrpos($type,':'));
$this->debug("got a prefixed type: $uqType, $ns");
if($ns == $this->XMLSchemaVersion ||
($this->getNamespaceFromPrefix($ns)) == $this->XMLSchemaVersion){
if (is_null($value)) {
if ($use == 'literal') {
return "<$name/>";
}else {
return "<$name xsi:nil=\"true\"/>";
}
}
if ($uqType == 'boolean'&&!$value) {
$value = 0;
}elseif ($uqType == 'boolean') {
$value = 1;
}
if ($uqType == 'string'&&gettype($value) == 'string') {
$value = $this->expandEntities($value);
}
if (!$this->getTypeDef($uqType)) {
if ($use == 'literal') {
return "<$name>$value</$name>";
}else {
return "<$name xsi:type=\"".$this->getPrefixFromNamespace($this->XMLSchemaVersion) .":$uqType\"$encodingStyle>$value</$name>";
}
}
}else if ($ns == 'http://xml.apache.org/xml-soap'||
($this->getNamespaceFromPrefix($ns)) == 'http://xml.apache.org/xml-soap') {
if ($uqType == 'Map') {
$contents = '';
foreach($value as $k =>$v) {
$this->debug("serializing map element: key $k, value $v");
$contents .= '<item>';
$contents .= $this->serialize_val($k,'key',false,false,false,false,$use);
$contents .= $this->serialize_val($v,'value',false,false,false,false,$use);
$contents .= '</item>';
}
if ($use == 'literal') {
return "<$name>$contents</$name>";
}else {
return "<$name xsi:type=\"".$this->getPrefixFromNamespace('http://xml.apache.org/xml-soap') .":$uqType\"$encodingStyle>$contents</$name>";
}
}
}
}else {
$uqType = $type;
}
if(!$typeDef = $this->getTypeDef($uqType)){
$this->setError("$type ($uqType) is not a supported type.");
return false;
}else {
}
$phpType = $typeDef['phpType'];
$this->debug("serializeType: uqType: $uqType, ns: $ns, phptype: $phpType, arrayType: ".(isset($typeDef['arrayType']) ?$typeDef['arrayType'] : '') );
if ($phpType == 'struct') {
if (isset($typeDef['element']) &&$typeDef['element']) {
$elementName = $uqType;
$elementNS = " xmlns=\"$ns\"";
}else {
$elementName = $name;
$elementNS = '';
}
if (is_null($value)) {
if ($use == 'literal') {
return "<$elementName$elementNS/>";
}else {
return "<$elementName$elementNS xsi:nil=\"true\"/>";
}
}
if ($use == 'literal') {
$xml = "<$elementName$elementNS>";
}else {
$xml = "<$elementName$elementNS xsi:type=\"".$this->getPrefixFromNamespace($ns) .":$uqType\"$encodingStyle>";
}
if (isset($this->complexTypes[$uqType]['elements']) &&is_array($this->complexTypes[$uqType]['elements'])) {
if(count($this->complexTypes[$uqType]['elements']) != count($value)){
$optionals = true;
}
foreach($this->complexTypes[$uqType]['elements'] as $eName =>$attrs) {
if(isset($optionals) &&!isset($value[$eName])){
}else {
if (isset($value[$eName])) {
$v = $value[$eName];
}else {
$v = null;
}
if($this->getTypeDef($this->getLocalPart($attrs['type']))) {
$xml .= $this->serializeType($eName,$attrs['type'],$v,$use,$encodingStyle);
}else {
$this->debug("calling serialize_val() for $eName, $v, ".$this->getLocalPart($attrs['type']),false,$use);
$xml .= $this->serialize_val($v,$eName,$this->getLocalPart($attrs['type']),null,$this->getNamespaceFromPrefix($this->getPrefix($attrs['type'])),false,$use);
}
}
}
}else {
}
$xml .= "</$elementName>";
}elseif ($phpType == 'array') {
if (is_null($value)) {
if ($use == 'literal') {
return "<$name/>";
}else {
return "<$name xsi:nil=\"true\"/>";
}
}
if (isset($typeDef['multidimensional'])) {
$nv = array();
foreach($value as $v) {
$cols = ','.sizeof($v);
$nv = array_merge($nv,$v);
}
$value = $nv;
}else {
$cols = '';
}
if (is_array($value) &&sizeof($value) >= 1) {
$rows = sizeof($value);
$contents = '';
foreach($value as $k =>$v) {
$this->debug("serializing array element: $k, $v of type: $typeDef[arrayType]");
if (!in_array($typeDef['arrayType'],$this->typemap['http://www.w3.org/2001/XMLSchema'])) {
$contents .= $this->serializeType('item',$typeDef['arrayType'],$v,$use);
}else {
$contents .= $this->serialize_val($v,'item',$typeDef['arrayType'],null,$this->XMLSchemaVersion,false,$use);
}
}
$this->debug('contents: '.$this->varDump($contents));
}else {
$rows = 0;
$contents = null;
}
if ($use == 'literal') {
$xml = "<$name>"
.$contents
."</$name>";
}else {
$xml = "<$name xsi:type=\"".$this->getPrefixFromNamespace('http://schemas.xmlsoap.org/soap/encoding/').':Array" '.
$this->getPrefixFromNamespace('http://schemas.xmlsoap.org/soap/encoding/')
.':arrayType="'
.$this->getPrefixFromNamespace($this->getPrefix($typeDef['arrayType']))
.":".$this->getLocalPart($typeDef['arrayType'])."[$rows$cols]\">"
.$contents
."</$name>";
}
}
$this->debug('returning: '.$this->varDump($xml));
return $xml;
}
function addOperation($name,$in = false,$out = false,$namespace = false,$soapaction = false,$style = 'rpc',$use = 'encoded',$documentation = ''){
if ($style == 'rpc'&&$use == 'encoded') {
$encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/';
}else {
$encodingStyle = '';
}
$this->bindings[$this->serviceName .'Binding']['operations'][$name] =
array(
'name'=>$name,
'binding'=>$this->serviceName .'Binding',
'endpoint'=>$this->endpoint,
'soapAction'=>$soapaction,
'style'=>$style,
'input'=>array(
'use'=>$use,
'namespace'=>$namespace,
'encodingStyle'=>$encodingStyle,
'message'=>$name .'Request',
'parts'=>$in),
'output'=>array(
'use'=>$use,
'namespace'=>$namespace,
'encodingStyle'=>$encodingStyle,
'message'=>$name .'Response',
'parts'=>$out),
'namespace'=>$namespace,
'transport'=>'http://schemas.xmlsoap.org/soap/http',
'documentation'=>$documentation);
if($in)
{
foreach($in as $pName =>$pType)
{
if(strpos($pType,':')) {
$pType = $this->getNamespaceFromPrefix($this->getPrefix($pType)).":".$this->getLocalPart($pType);
}
$this->messages[$name.'Request'][$pName] = $pType;
}
}else {
$this->messages[$name.'Request']= '0';
}
if($out)
{
foreach($out as $pName =>$pType)
{
if(strpos($pType,':')) {
$pType = $this->getNamespaceFromPrefix($this->getPrefix($pType)).":".$this->getLocalPart($pType);
}
$this->messages[$name.'Response'][$pName] = $pType;
}
}else {
$this->messages[$name.'Response']= '0';
}
return true;
}
}
class soap_parser extends nusoap_base {
var $xml = '';
var $xml_encoding = '';
var $method = '';
var $root_struct = '';
var $root_struct_name = '';
var $root_header = '';
var $document = '';
var $status = '';
var $position = 0;
var $depth = 0;
var $default_namespace = '';
var $namespaces = array();
var $message = array();
var $parent = '';
var $fault = false;
var $fault_code = '';
var $fault_str = '';
var $fault_detail = '';
var $depth_array = array();
var $debug_flag = true;
var $soapresponse = NULL;
var $responseHeaders = '';
var $body_position = 0;
var $ids = array();
var $multirefs = array();
var $decode_utf8 = true;
function soap_parser($xml,$encoding='UTF-8',$method='',$decode_utf8=true){
$this->xml = $xml;
$this->xml_encoding = $encoding;
$this->method = $method;
$this->decode_utf8 = $decode_utf8;
if(!empty($xml)){
$this->debug('Entering soap_parser(), length='.strlen($xml).', encoding='.$encoding);
$this->parser = xml_parser_create($this->xml_encoding);
xml_parser_set_option($this->parser,XML_OPTION_CASE_FOLDING,0);
xml_parser_set_option($this->parser,XML_OPTION_TARGET_ENCODING,$this->xml_encoding);
xml_set_object($this->parser,$this);
xml_set_element_handler($this->parser,'start_element','end_element');
xml_set_character_data_handler($this->parser,'character_data');
if(!xml_parse($this->parser,$xml,true)){
$err = sprintf('XML error on line %d: %s',
xml_get_current_line_number($this->parser),
xml_error_string(xml_get_error_code($this->parser)));
$this->debug('parse error: '.$err);
$this->setError($err);
}else {
$this->debug('parsed successfully, found root struct: '.$this->root_struct.' of name '.$this->root_struct_name);
$this->soapresponse = $this->message[$this->root_struct]['result'];
if($this->root_header != ''&&isset($this->message[$this->root_header]['result'])){
$this->responseHeaders = $this->message[$this->root_header]['result'];
}
if(sizeof($this->multirefs) >0){
foreach($this->multirefs as $id =>$hrefs){
$this->debug('resolving multirefs for id: '.$id);
$idVal = $this->buildVal($this->ids[$id]);
foreach($hrefs as $refPos =>$ref){
$this->debug('resolving href at pos '.$refPos);
$this->multirefs[$id][$refPos] = $idVal;
}
}
}
}
xml_parser_free($this->parser);
}else {
$this->debug('xml was empty, didn\'t parse!');
$this->setError('xml was empty, didn\'t parse!');
}
}
function start_element($parser,$name,$attrs) {
$pos = $this->position++;
$this->message[$pos] = array('pos'=>$pos,'children'=>'','cdata'=>'');
$this->message[$pos]['depth'] = $this->depth++;
if($pos != 0){
$this->message[$this->parent]['children'] .= '|'.$pos;
}
$this->message[$pos]['parent'] = $this->parent;
$this->parent = $pos;
$this->depth_array[$this->depth] = $pos;
if(strpos($name,':')){
$prefix = substr($name,0,strpos($name,':'));
$name = substr(strstr($name,':'),1);
}
if($name == 'Envelope'){
$this->status = 'envelope';
}elseif($name == 'Header'){
$this->root_header = $pos;
$this->status = 'header';
}elseif($name == 'Body'){
$this->status = 'body';
$this->body_position = $pos;
}elseif($this->status == 'body'&&$pos == ($this->body_position+1)){
$this->status = 'method';
$this->root_struct_name = $name;
$this->root_struct = $pos;
$this->message[$pos]['type'] = 'struct';
$this->debug("found root struct $this->root_struct_name, pos $this->root_struct");
}
$this->message[$pos]['status'] = $this->status;
$this->message[$pos]['name'] = htmlspecialchars($name);
$this->message[$pos]['attrs'] = $attrs;
$attstr = '';
foreach($attrs as $key =>$value){
$key_prefix = $this->getPrefix($key);
$key_localpart = $this->getLocalPart($key);
if($key_prefix == 'xmlns'){
if(ereg('^http://www.w3.org/[0-9]{4}/XMLSchema$',$value)){
$this->XMLSchemaVersion = $value;
$this->namespaces['xsd'] = $this->XMLSchemaVersion;
$this->namespaces['xsi'] = $this->XMLSchemaVersion.'-instance';
}
$this->namespaces[$key_localpart] = $value;
if($name == $this->root_struct_name){
$this->methodNamespace = $value;
}
}elseif($key_localpart == 'type'){
$value_prefix = $this->getPrefix($value);
$value_localpart = $this->getLocalPart($value);
$this->message[$pos]['type'] = $value_localpart;
$this->message[$pos]['typePrefix'] = $value_prefix;
if(isset($this->namespaces[$value_prefix])){
$this->message[$pos]['type_namespace'] = $this->namespaces[$value_prefix];
}else if(isset($attrs['xmlns:'.$value_prefix])) {
$this->message[$pos]['type_namespace'] = $attrs['xmlns:'.$value_prefix];
}
}elseif($key_localpart == 'arrayType'){
$this->message[$pos]['type'] = 'array';
$expr = '([A-Za-z0-9_]+):([A-Za-z]+[A-Za-z0-9_]+)\[([0-9]+),?([0-9]*)\]';
if(ereg($expr,$value,$regs)){
$this->message[$pos]['typePrefix'] = $regs[1];
$this->message[$pos]['arrayTypePrefix'] = $regs[1];
if (isset($this->namespaces[$regs[1]])) {
$this->message[$pos]['arrayTypeNamespace'] = $this->namespaces[$regs[1]];
}else if (isset($attrs['xmlns:'.$regs[1]])) {
$this->message[$pos]['arrayTypeNamespace'] = $attrs['xmlns:'.$regs[1]];
}
$this->message[$pos]['arrayType'] = $regs[2];
$this->message[$pos]['arraySize'] = $regs[3];
$this->message[$pos]['arrayCols'] = $regs[4];
}
}
if($key == 'id'){
$this->ids[$value] = $pos;
}
if($key_localpart == 'root'&&$value == 1){
$this->status = 'method';
$this->root_struct_name = $name;
$this->root_struct = $pos;
$this->debug("found root struct $this->root_struct_name, pos $pos");
}
$attstr .= " $key=\"$value\"";
}
if(isset($prefix)){
$this->message[$pos]['namespace'] = $this->namespaces[$prefix];
$this->default_namespace = $this->namespaces[$prefix];
}else {
$this->message[$pos]['namespace'] = $this->default_namespace;
}
if($this->status == 'header'){
$this->responseHeaders .= "<$name$attstr>";
}elseif($this->root_struct_name != ''){
$this->document .= "<$name$attstr>";
}
}
function end_element($parser,$name) {
$pos = $this->depth_array[$this->depth--];
if(strpos($name,':')){
$prefix = substr($name,0,strpos($name,':'));
$name = substr(strstr($name,':'),1);
}
if(isset($this->body_position) &&$pos >$this->body_position){
if(isset($this->message[$pos]['attrs']['href'])){
$id = substr($this->message[$pos]['attrs']['href'],1);
$this->multirefs[$id][$pos] = 'placeholder';
$this->message[$pos]['result'] =&$this->multirefs[$id][$pos];
}elseif($this->message[$pos]['children'] != ''){
if(!isset($this->message[$pos]['result'])){
$this->message[$pos]['result'] = $this->buildVal($pos);
}
}else {
if (isset($this->message[$pos]['type'])) {
$this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'],$this->message[$pos]['type'],isset($this->message[$pos]['type_namespace']) ?$this->message[$pos]['type_namespace'] : '');
}else {
$parent = $this->message[$pos]['parent'];
if (isset($this->message[$parent]['type']) &&($this->message[$parent]['type'] == 'array') &&isset($this->message[$parent]['arrayType'])) {
$this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'],$this->message[$parent]['arrayType'],isset($this->message[$parent]['arrayTypeNamespace']) ?$this->message[$parent]['arrayTypeNamespace'] : '');
}else {
$this->message[$pos]['result'] = $this->message[$pos]['cdata'];
}
}
}
}
if($pos == $this->root_struct){
$this->status = 'body';
}elseif($name == 'Body'){
$this->status = 'header';
}elseif($name == 'Header'){
$this->status = 'envelope';
}elseif($name == 'Envelope'){
}
$this->parent = $this->message[$pos]['parent'];
if($this->status == 'header'){
$this->responseHeaders .= "</$name>";
}elseif($pos >= $this->root_struct){
$this->document .= "</$name>";
}
}
function character_data($parser,$data){
$pos = $this->depth_array[$this->depth];
if ($this->xml_encoding=='UTF-8'){
if($this->decode_utf8){
$data = utf8_decode($data);
}
}
$this->message[$pos]['cdata'] .= $data;
if($this->status == 'header'){
$this->responseHeaders .= $data;
}else {
$this->document .= $data;
}
}
function get_response(){
return $this->soapresponse;
}
function getHeaders(){
return $this->responseHeaders;
}
function decode_entities($text){
foreach($this->entities as $entity =>$encoded){
$text = str_replace($encoded,$entity,$text);
}
return $text;
}
function decodeSimple($value,$type,$typens) {
if ((!isset($type)) ||$type == 'string'||$type == 'long'||$type == 'unsignedLong') {
return (string) $value;
}
if ($type == 'int'||$type == 'integer'||$type == 'short'||$type == 'byte') {
return (int) $value;
}
if ($type == 'float'||$type == 'double'||$type == 'decimal') {
return (double) $value;
}
if ($type == 'boolean') {
if (strtolower($value) == 'false'||strtolower($value) == 'f') {
return false;
}
return (boolean) $value;
}
if ($type == 'base64'||$type == 'base64Binary') {
return base64_decode($value);
}
if ($type == 'nonPositiveInteger'||$type == 'negativeInteger'
||$type == 'nonNegativeInteger'||$type == 'positiveInteger'
||$type == 'unsignedInt'
||$type == 'unsignedShort'||$type == 'unsignedByte') {
return (int) $value;
}
return (string) $value;
}
function buildVal($pos){
if(!isset($this->message[$pos]['type'])){
$this->message[$pos]['type'] = '';
}
$this->debug('inside buildVal() for '.$this->message[$pos]['name']."(pos $pos) of type ".$this->message[$pos]['type']);
if($this->message[$pos]['children'] != ''){
$children = explode('|',$this->message[$pos]['children']);
array_shift($children);
if(isset($this->message[$pos]['arrayCols']) &&$this->message[$pos]['arrayCols'] != ''){
$r=0;
$c=0;
foreach($children as $child_pos){
$this->debug("got an MD array element: $r, $c");
$params[$r][] = $this->message[$child_pos]['result'];
$c++;
if($c == $this->message[$pos]['arrayCols']){
$c = 0;
$r++;
}
}
}elseif($this->message[$pos]['type'] == 'array'||$this->message[$pos]['type'] == 'Array'){
$this->debug('adding array '.$this->message[$pos]['name']);
foreach($children as $child_pos){
$params[] = &$this->message[$child_pos]['result'];
}
}elseif($this->message[$pos]['type'] == 'Map'&&$this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap'){
foreach($children as $child_pos){
$kv = explode("|",$this->message[$child_pos]['children']);
$params[$this->message[$kv[1]]['result']] = &$this->message[$kv[2]]['result'];
}
}else {
if ($this->message[$pos]['type'] == 'Vector'&&$this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
$notstruct = 1;
}else {
foreach($children as $child_pos){
if(isset($keys) &&isset($keys[$this->message[$child_pos]['name']])){
$notstruct = 1;
break;
}
$keys[$this->message[$child_pos]['name']] = 1;
}
}
foreach($children as $child_pos){
if(isset($notstruct)){
$params[] = &$this->message[$child_pos]['result'];
}else {
$params[$this->message[$child_pos]['name']] = &$this->message[$child_pos]['result'];
}
}
}
return is_array($params) ?$params : array();
}else {
$this->debug('no children');
if(strpos($this->message[$pos]['cdata'],'&')){
return  strtr($this->message[$pos]['cdata'],array_flip($this->entities));
}else {
return $this->message[$pos]['cdata'];
}
}
}
}
class soapclient extends nusoap_base  {
var $username = '';
var $password = '';
var $requestHeaders = false;
var $responseHeaders;
var $endpoint;
var $error_str = false;
var $proxyhost = '';
var $proxyport = '';
var $proxyusername = '';
var $proxypassword = '';
var $xml_encoding = '';
var $http_encoding = false;
var $timeout = 0;
var $endpointType = '';
var $persistentConnection = false;
var $defaultRpcParams = false;
var $request = '';
var $response = '';
var $responseData = '';
var $decode_utf8 = true;
var $fault,$faultcode,$faultstring,$faultdetail;
function soapclient($endpoint,$wsdl = false,$proxyhost = false,$proxyport = false,$proxyusername = false,$proxypassword = false){
$this->endpoint = $endpoint;
$this->proxyhost = $proxyhost;
$this->proxyport = $proxyport;
$this->proxyusername = $proxyusername;
$this->proxypassword = $proxypassword;
if($wsdl){
$this->endpointType = 'wsdl';
$this->wsdlFile = $this->endpoint;
$this->debug('instantiating wsdl class with doc: '.$endpoint);
$this->wsdl =&new wsdl($this->wsdlFile,$this->proxyhost,$this->proxyport,$this->proxyusername,$this->proxypassword);
$this->debug("wsdl debug: \n".$this->wsdl->debug_str);
$this->wsdl->debug_str = '';
if($errstr = $this->wsdl->getError()){
$this->debug('got wsdl error: '.$errstr);
$this->setError('wsdl error: '.$errstr);
}elseif($this->operations = $this->wsdl->getOperations()){
$this->debug( 'got '.count($this->operations).' operations from wsdl '.$this->wsdlFile);
}else {
$this->debug( 'getOperations returned false');
$this->setError('no operations defined in the WSDL document!');
}
}
}
function call($operation,$params=array(),$namespace='',$soapAction='',$headers=false,$rpcParams=null){
$this->operation = $operation;
$this->fault = false;
$this->error_str = '';
$this->request = '';
$this->response = '';
$this->responseData = '';
$this->faultstring = '';
$this->faultcode = '';
$this->opData = array();
$this->debug("call: $operation, $params, $namespace, $soapAction, $headers, $rpcParams");
$this->debug("endpointType: $this->endpointType");
if ($headers) {
$this->requestHeaders = $headers;
}
if($this->endpointType == 'wsdl'&&$opData = $this->getOperationData($operation)){
$this->opData = $opData;
foreach($opData as $key =>$value){
$this->debug("$key -> $value");
}
$soapAction = $opData['soapAction'];
$this->endpoint = $opData['endpoint'];
$namespace = isset($opData['input']['namespace']) ?$opData['input']['namespace'] :	'http://testuri.org';
$style = $opData['style'];
if($namespace != ''&&!isset($this->wsdl->namespaces[$namespace])){
$this->wsdl->namespaces['nu'] = $namespace;
}
if($opData['input']['use'] == 'literal') {
if (is_null($rpcParams)) {
$rpcParams = $this->defaultRpcParams;
}
if ($rpcParams) {
$this->debug("serializing literal params for operation $operation");
$payload = $this->wsdl->serializeRPCParameters($operation,'input',$params);
$defaultNamespace = $this->wsdl->wsdl_info['targetNamespace'];
var_dump($params);
}else {
$this->debug("serializing literal document for operation $operation");
$payload = $this->wsdl->serializeParameters($operation,'input',$params);
}
}else {
$this->debug("serializing encoded params for operation $operation");
$encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/';
$payload = "<".$this->wsdl->getPrefixFromNamespace($namespace).":$operation";
if(isset($opData['output']['encodingStyle']) &&$encodingStyle != $opData['output']['encodingStyle']) {
$payload .= (' SOAP:encodingStyle="'.$opData['output']['encodingStyle'] .'"');
}
$payload .= ('>'.$this->wsdl->serializeRPCParameters($operation,'input',$params).
'</'.$this->wsdl->getPrefixFromNamespace($namespace).":$operation>");
}
$this->debug('payload size: '.strlen($payload));
$soapmsg = $this->serializeEnvelope($payload,$this->requestHeaders,$this->wsdl->usedNamespaces,$style);
$this->debug("wsdl debug: \n".$this->wsdl->debug_str);
$this->wsdl->debug_str = '';
if ($errstr = $this->wsdl->getError()) {
$this->debug('got wsdl error: '.$errstr);
$this->setError('wsdl error: '.$errstr);
return false;
}
}elseif($this->endpointType == 'wsdl') {
$this->setError( 'operation '.$operation.' not present.');
$this->debug("operation '$operation' not present.");
$this->debug("wsdl debug: \n".$this->wsdl->debug_str);
$this->wsdl->debug_str = '';
return false;
}else {
if(!isset($style)){
$style = 'rpc';
}
if($namespace == ''){
$namespace = 'http://testuri.org';
$this->wsdl->namespaces['ns1'] = $namespace;
}
$payload = '';
if(is_array($params)){
foreach($params as $k =>$v){
$payload .= $this->serialize_val($v,$k);
}
}
$payload = "<$operation xmlns=\"$namespace\">".$payload."</$operation>";
$soapmsg = $this->serializeEnvelope($payload,$this->requestHeaders);
}
$this->debug("endpoint: $this->endpoint, soapAction: $soapAction, namespace: $namespace");
$this->debug('sending msg (len: '.strlen($soapmsg).") w/ soapaction '$soapAction'...");
$return = $this->send($this->getHTTPBody($soapmsg),$soapAction,$this->timeout);
if($errstr = $this->getError()){
$this->debug('Error: '.$errstr);
return false;
}else {
$this->return = $return;
$this->debug('sent message successfully and got a(n) '.gettype($return).' back');
if(is_array($return) &&isset($return['faultcode'])){
$this->debug('got fault');
$this->setError($return['faultcode'].': '.$return['faultstring']);
$this->fault = true;
foreach($return as $k =>$v){
$this->$k = $v;
$this->debug("$k = $v<br>");
}
return $return;
}else {
if(is_array($return)){
if(sizeof($return) >1){
return $return;
}
return array_shift($return);
}else {
return "";
}
}
}
}
function getOperationData($operation){
if(isset($this->operations[$operation])){
return $this->operations[$operation];
}
$this->debug("No data for operation: $operation");
}
function send($msg,$soapaction = '',$timeout=0) {
switch(true){
case ereg('^http',$this->endpoint):
$this->debug('transporting via HTTP');
if($this->persistentConnection == true &&is_object($this->persistentConnection)){
$http =&$this->persistentConnection;
}else {
$http = new soap_transport_http($this->endpoint);
if ($this->persistentConnection) {
$http->usePersistentConnection();
}
}
$http->setContentType($this->getHTTPContentType(),$this->getHTTPContentTypeCharset());
$http->setSOAPAction($soapaction);
if($this->proxyhost &&$this->proxyport){
$http->setProxy($this->proxyhost,$this->proxyport,$this->proxyusername,$this->proxypassword);
}
if($this->username != ''&&$this->password != '') {
$http->setCredentials($this->username,$this->password);
}
if($this->http_encoding != ''){
$http->setEncoding($this->http_encoding);
}
$this->debug('sending message, length: '.strlen($msg));
if(ereg('^http:',$this->endpoint)){
$this->responseData = $http->send($msg,$timeout);
}elseif(ereg('^https',$this->endpoint)){
if (extension_loaded('curl')) {
$this->responseData = $http->sendHTTPS($msg,$timeout);
}else {
$this->setError('CURL Extension, or OpenSSL extension w/ PHP version >= 4.3 is required for HTTPS');
}
}else {
$this->setError('no http/s in endpoint url');
}
$this->request = $http->outgoing_payload;
$this->response = $http->incoming_payload;
$this->debug("transport debug data...\n".$http->debug_str);
if($this->persistentConnection &&!is_object($this->persistentConnection)){
$this->persistentConnection = $http;
}
if($err = $http->getError()){
$this->setError('HTTP Error: '.$err);
return false;
}elseif($this->getError()){
return false;
}else {
$this->debug('got response, length: '.strlen($this->responseData).' type: '.$http->incoming_headers['content-type']);
return $this->parseResponse($http->incoming_headers,$this->responseData);
}
break;
default:
$this->setError('no transport found, or selected transport is not yet supported!');
return false;
break;
}
}
function parseResponse($headers,$data) {
$this->debug('Entering parseResponse() for data of length '.strlen($data) .' and type '.$headers['content-type']);
if (!strstr($headers['content-type'],'text/xml')) {
$this->setError('Response not of type text/xml');
return false;
}
if (strpos($headers['content-type'],'=')) {
$enc = str_replace('"','',substr(strstr($headers["content-type"],'='),1));
$this->debug('Got response encoding: '.$enc);
if(eregi('^(ISO-8859-1|US-ASCII|UTF-8)$',$enc)){
$this->xml_encoding = strtoupper($enc);
}else {
$this->xml_encoding = 'US-ASCII';
}
}else {
$this->xml_encoding = 'UTF-8';
}
$this->debug('Use encoding: '.$this->xml_encoding .' when creating soap_parser');
$parser = new soap_parser($data,$this->xml_encoding,$this->operation,$this->decode_utf8);
if($errstr = $parser->getError()){
$this->setError( $errstr);
unset($parser);
return false;
}else {
$this->responseHeaders = $parser->getHeaders();
$return = $parser->get_response();
$this->debug($parser->debug_str);
$this->document = $parser->document;
unset($parser);
return $return;
}
}
function setHeaders($headers){
$this->requestHeaders = $headers;
}
function getHeaders(){
if($this->responseHeaders != '') {
return $this->responseHeaders;
}
}
function setHTTPProxy($proxyhost,$proxyport,$proxyusername = '',$proxypassword = '') {
$this->proxyhost = $proxyhost;
$this->proxyport = $proxyport;
$this->proxyusername = $proxyusername;
$this->proxypassword = $proxypassword;
}
function setCredentials($username,$password) {
$this->username = $username;
$this->password = $password;
}
function setHTTPEncoding($enc='gzip, deflate'){
$this->http_encoding = $enc;
}
function useHTTPPersistentConnection(){
$this->persistentConnection = true;
}
function getDefaultRpcParams() {
return $this->defaultRpcParams;
}
function setDefaultRpcParams($rpcParams) {
$this->defaultRpcParams = $rpcParams;
}
function getProxy(){
$evalStr = '';
foreach($this->operations as $operation =>$opData){
if($operation != ''){
$paramStr = '';
if(sizeof($opData['input']['parts']) >0){
foreach($opData['input']['parts'] as $name =>$type){
$paramStr .= "\$$name,";
}
$paramStr = substr($paramStr,0,strlen($paramStr)-1);
}
$opData['namespace'] = !isset($opData['namespace']) ?'http://testuri.com': $opData['namespace'];
$evalStr .= "function $operation ($paramStr){
					// load params into array
					\$params = array($paramStr);
					return \$this->call('$operation',\$params,'".$opData['namespace']."','".$opData['soapAction']."');
				}";
unset($paramStr);
}
}
$r = rand();
$evalStr = 'class soap_proxy_'.$r.' extends soapclient {
				'.$evalStr.'
			}';
eval($evalStr);
eval("\$proxy = new soap_proxy_$r('');");
$proxy->endpointType = 'wsdl';
$proxy->wsdlFile = $this->wsdlFile;
$proxy->wsdl = $this->wsdl;
$proxy->operations = $this->operations;
$proxy->defaultRpcParams = $this->defaultRpcParams;
return $proxy;
}
function getHTTPBody($soapmsg) {
return $soapmsg;
}
function getHTTPContentType() {
return 'text/xml';
}
function getHTTPContentTypeCharset() {
return $this->soap_defencoding;
}
function decodeUTF8($bool){
$this->decode_utf8 = $bool;
return true;
}
}
?>
